﻿using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;

namespace yDevice.ExpanderDevice
{
    /// <summary>
    /// 模拟量转数字量3060N
    /// </summary>
    public class DMADev
    {
        private IntPtr intPtr;
        private ushort[] analogDatas = new ushort[8];
        private bool isConnected = false;
        private string ip;
        private int port;        

        /// <summary>
        /// 数字量数据
        /// </summary>
        public double[] DigitalDatas = new double[8];

        public DMADev(string ip, int port)
        {
            this.ip = ip;
            this.port = port;
            GetRealData();
        }

        public bool Connected() => isConnected;

        public bool Disposed() => Dispose();

        private void GetRealData()
        {
            Task.Run(() =>
            {
                while (true)
                {
                    Connect();
                    if (isConnected)
                    {
                        DAME3000N.DAME3000N_AIReadData(intPtr, analogDatas, 0, 7);
                        for (int i = 0; i < analogDatas.Length; i++)
                        {
                            DigitalDatas[i] = analogDatas[i] / 13107f;
                        }
                    }
                    Thread.Sleep(10);
                }
            });
        }

        private void Connect()
        {
            if (!isConnected)
            {
                if (Dispose())
                {
                    intPtr = DAME3000N.DAME3000N_CreateDevice(Encoding.Default.GetBytes(ip), port, 1000, 1000);
                    isConnected = intPtr == (IntPtr)(-1);
                }
            }
        }

        private bool Dispose()
        {
            int result = -1;
            try
            {
                result = DAME3000.DAME3000_ReleaseDevice(intPtr);
            }
            catch { }
            return result != -1;
        }
    }

    public class DAM3000M
    {

        // ********************* 开关量输出的参数结构 ****************************
        public struct DAM3000M_PARA_DO          // 数字量输出参数
        {
            public Byte DO0;        // 0通道
            public Byte DO1;        // 1通道
            public Byte DO2;        // 2通道
            public Byte DO3;        // 3通道
            public Byte DO4;        // 4通道
            public Byte DO5;        // 5通道
            public Byte DO6;        // 6通道
            public Byte DO7;        // 7通道
            public Byte DO8;            // 8通道
            public Byte DO9;            // 9通道
            public Byte DO10;       // 10通道
            public Byte DO11;       // 11通道
            public Byte DO12;       // 12通道
            public Byte DO13;           // 13通道
            public Byte DO14;           // 14通道
            public Byte DO15;           // 15通道
        }


        // ********************* 开关量输入的参数结构 *******************************
        public struct DAM3000M_PARA_DI      // 数字量输入参数(1为高电平)
        {
            public Byte DI0;            // 0通道
            public Byte DI1;            // 1通道
            public Byte DI2;            // 2通道
            public Byte DI3;            // 3通道
            public Byte DI4;            // 4通道
            public Byte DI5;            // 5通道
            public Byte DI6;            // 6通道
            public Byte DI7;            // 7通道
            public Byte DI8;            // 8通道
            public Byte DI9;            // 9通道
            public Byte DI10;           // 10通道
            public Byte DI11;           // 11通道
            public Byte DI12;           // 12通道
            public Byte DI13;           // 13通道
            public Byte DI14;           // 14通道
            public Byte DI15;           // 15通道
            public Byte DI16;           // 16通道
            public Byte DI17;           // 17通道
            public Byte DI18;           // 18通道
            public Byte DI19;           // 19通道
            public Byte DI20;           // 20通道
            public Byte DI21;           // 21通道
            public Byte DI22;           // 22通道
            public Byte DI23;           // 23通道
            public Byte DI24;           // 24通道
            public Byte DI25;           // 25通道
            public Byte DI26;           // 26通道
            public Byte DI27;           // 27通道
            public Byte DI28;           // 28通道
            public Byte DI29;           // 29通道
            public Byte DI30;           // 30通道
            public Byte DI31;           // 31通道
        }

        public struct DAM3000M_PARA_LATCH      // 数字量锁存参数(1为锁存)
        {
            public Byte Latch0;     // 0通道
            public Byte Latch1;        // 1通道
            public Byte Latch2;        // 2通道
            public Byte Latch3;        // 3通道
            public Byte Latch4;        // 4通道
            public Byte Latch5;        // 5通道
            public Byte Latch6;        // 6通道
            public Byte Latch7;        // 7通道
            public Byte Latch8;        // 8通道
            public Byte Latch9;        // 9通道
            public Byte Latch10;       // 10通道
            public Byte Latch11;       // 11通道
            public Byte Latch12;       // 12通道
            public Byte Latch13;       // 13通道
            public Byte Latch14;       // 14通道
            public Byte Latch15;       // 15通道
            public Byte Latch16;       // 16通道
            public Byte Latch17;       // 17通道
            public Byte Latch18;       // 18通道
            public Byte Latch19;       // 19通道
            public Byte Latch20;       // 20通道
            public Byte Latch21;       // 21通道
            public Byte Latch22;       // 22通道
            public Byte Latch23;       // 23通道
            public Byte Latch24;       // 24通道
            public Byte Latch25;       // 25通道
            public Byte Latch26;       // 26通道
            public Byte Latch27;       // 27通道
            public Byte Latch28;       // 28通道
            public Byte Latch29;       // 29通道
            public Byte Latch30;       // 30通道
            public Byte Latch31;       // 31通道
        }


        // ****************** 模拟量输入通道配置结构体 *************************
        public struct DAM3000M_ADCHANNEL_ARRAY
        {
            public Byte bChannel0;      // 1，有效；0，无效
            public Byte bChannel1;
            public Byte bChannel2;
            public Byte bChannel3;
            public Byte bChannel4;
            public Byte bChannel5;
            public Byte bChannel6;
            public Byte bChannel7;
        }


        // ****************** 计数器参数配置结构体 ******************************
        public struct DAM3000M_PARA_CNT         // 基于各通道的计数器参数结构体
        {
            public Int32 WorkMode;          // 计数器/频率工作模式
            public Int32 FreqBuildTime;     // 测频器建立时间, 单位: s
            public Int32 InputMode;         // 计数器/频率输入方式	0: 非隔离	1: 隔离
            public UInt32 InitVal;          // 计数器初始值
            public UInt32 MaxVal;           // 计数器最大值
            public Int32 GateSts;           // 门槛值状态(计数模式)
        }

        public struct DAM3000M_CNT_ALARM
        {
            public Int32 AlarmMode;         // 报警方式	
            public Int32 EnableAlarm0;      // 0通道报警使能
            public Int32 EnableAlarm1;      // 1通道报警使能
            public UInt32 Alarm0Val;        // 0通道报警值
            public UInt32 Alarm1Val;        // 1通道报警值
            public UInt32 Alarm0HiHiVal;    // 0通道上上限(Hi-Hi)报警值, 报警方式1有效
        }

        public struct DAM3000M_PARA_FILTER      // 用于计数器滤波的参数结构体
        {
            public Int32 TrigLevelHigh;     // 触发高电平(非隔离输入)
            public Int32 TrigLevelLow;      // 触发低电平(非隔离输入)
            public Int32 MinWidthHigh;      // 高电平最小输入信号宽度
            public Int32 MinWidthLow;       // 低电平最小输入信号宽度
            public Int32 bEnableFilter;     // 使能滤波
        }
        //	DisplayChannel;	// 设置显示通道		0：0通道计数/频率，1：1通道计数/频率


        public struct DAM3000M_CNT_STATUS           // 计数器硬件参数状态结构体
        {
            public Int32 WorkMode;          // 计数器/频率工作模式*
            public Int32 FreqBuildTime;     // 测频器建立时间, 单位: s*
            public Int32 InputMode;         // 计数器/频率输入方式	0: 非隔离	1: 隔离*
            public Int32 bCNTSts;           // 计数/频率器的状态(起停状态)*
            public Int32 FilterSts;         // 计数器的滤波状态*
            public Int32 MinWidthHigh;      // 高电平最小输入信号宽度*
            public Int32 MinWidthLow;       // 低电平最小输入信号宽度*
            public Int32 TrigLevelHigh;     // 触发高电平(非隔离输入)*
            public Int32 TrigLevelLow;      // 触发低电平(非隔离输入)*
            public Int32 GateSts;           // 门槛值设置状态(计数模式)*
            public UInt32 MaxVal;           // 计数器最大值*
            public UInt32 InitVal;          // 计数器初始值*
            public Int32 bOverflowSts;      // 计数器溢出状态*
            public Int32 AlarmMode;         // 计数器报警方式*
            public Int32 EnableAlarm0;      // 计数器0报警使能状态*
            public Int32 EnableAlarm1;      // 计数器1报警使能状态*
            public UInt32 Alarm0Val;        // 0通道报警值*
            public UInt32 Alarm1Val;        // 1通道报警值*
            public UInt32 Alarm1HiHiVal;    // 报警方式1上上限(Hi-Hi)报警值*
            public Int32 bDO0;              // DO0*
            public Int32 bDO1;              // DO1*
        }


        // ****************** 设备基本信息的结构体 ******************************
        public struct DAM3000M_DEVICE_INFO
        {
            public Int32 DeviceType;        // 模块类型 
            public Int32 TypeSuffix;        // 类型后缀
            public Int32 ModusType;     // M
            public Int32 VesionID;      // 版本号(2字节)
            public Int32 DeviceID;      // 模块ID号(SetDeviceInfo时，为设备的新ID)
            public Int32 BaudRate;      // 波特率
            public Int32 bParity;       // 无校验 偶校验 奇校验(目前仅支持3080D)
        }


        // ****************** 测温模块传感器参数的结构体 ******************************
        public struct DAM3000M_SENSOR_PARA
        {
            public Byte SerialNumber;   // 编号
            public Byte Channel;        // 所在通道号
            public Byte SequenceNumber; // 通道内顺序号
            public UInt16 Temperature;  // 温度
            public Byte ID0;            // ID号0
            public Byte ID1;            // ID号1
            public Byte ID2;            // ID号2
            public Byte ID3;            // ID号3
            public Byte ID4;            // ID号4
            public Byte ID5;            // ID号5
            public Byte ID6;            // ID号6
            public Byte ID7;            // ID号7
            public Byte AlarmMark;      // 报警标志
        }


        // 模拟量输入类型(电压类型) 供DAM3000M_SetModeAD函数中的lMode参数使用
        public const Int32 DAM3000M_VOLT_N15_P15 = 0x01; //  -15～+15mV
        public const Int32 DAM3000M_VOLT_N50_P50 = 0x02; //  -50～+50mV
        public const Int32 DAM3000M_VOLT_N100_P100 = 0x03; // -100～+100mV
        public const Int32 DAM3000M_VOLT_N150_P150 = 0x04; // -150～+150mV
        public const Int32 DAM3000M_VOLT_N500_P500 = 0x05; // -500～+500mV
        public const Int32 DAM3000M_VOLT_N1_P1 = 0x06; //   -1～+1V
        public const Int32 DAM3000M_VOLT_N25_P25 = 0x07; // -2.5～+2.5V
        public const Int32 DAM3000M_VOLT_N5_P5 = 0x08; //   -5～+5V
        public const Int32 DAM3000M_VOLT_N10_P10 = 0x09; //  -10～+10V
        public const Int32 DAM3000M_VOLT_N0_P5 = 0x0D; //    0～+5V
        public const Int32 DAM3000M_VOLT_N0_P10 = 0x0E; //    0～+10V
        public const Int32 DAM3000M_VOLT_N0_P25 = 0x0F; //    0～+2.5V
        public const Int32 DAM3000M_VOLT_N1_P5 = 0x82; //    1～+5V
        public const Int32 DAM3000M_VOLT_N30_P30V = 0x83; //  -30～+30V
        public const Int32 DAM3000M_VOLT_N0_P30V = 0x84; //    0～+30V

        // 模拟量输入类型(电流类型) 供DAM3000M_SetModeAD函数中的lMode参数使用
        public const Int32 DAM3000M_CUR_N0_P10 = 0x00; //   0～10mA
        public const Int32 DAM3000M_CUR_N20_P20 = 0x0A; // -20～+20mA
        public const Int32 DAM3000M_CUR_N0_P20 = 0x0B; //   0～20mA
        public const Int32 DAM3000M_CUR_N4_P20 = 0x0C; //   4～20mA
        public const Int32 DAM3000M_CUR_N0_P22 = 0x80; //   0～22mA
        public const Int32 DAM3000M_CUR_N10_P10A = 0x85; // -10～+10A
        public const Int32 DAM3000M_CUR_N0_P10A = 0x86; //   0～+10A

        // 模拟量输入类型(热电偶类型) 供DAM3000M_SetModeAD函数中的lMode参数使用
        public const Int32 DAM3000M_TMC_J = 0x10; // J型热电偶   0～1200℃
        public const Int32 DAM3000M_TMC_K = 0x11; // K型热电偶   0～1300℃
        public const Int32 DAM3000M_TMC_T = 0x12; // T型热电偶 -200～400℃
        public const Int32 DAM3000M_TMC_E = 0x13; // E型热电偶   0～1000℃
        public const Int32 DAM3000M_TMC_R = 0x14; // R型热电偶 500～1700℃
        public const Int32 DAM3000M_TMC_S = 0x15; // S型热电偶 500～1768℃
        public const Int32 DAM3000M_TMC_B = 0x16; // B型热电偶 500～1800℃
        public const Int32 DAM3000M_TMC_N = 0x17; // N型热电偶   0～1300℃
        public const Int32 DAM3000M_TMC_C = 0x18; // C型热电偶   0～2090℃
        public const Int32 DAM3000M_TMC_WRE = 0x19; // 钨铼5-钨铼26 0～2310℃

        // 模拟量输入类型(热电阻类型) 供DAM3000M_SetModeAD函数中的lMode参数使用
        public const Int32 DAM3000M_RTD_PT100_385_N200_P850 = 0x20; // Pt100(385)热电阻 -200℃～850℃
        public const Int32 DAM3000M_RTD_PT100_385_N100_P100 = 0x21; // Pt100(385)热电阻 -100℃～100℃
        public const Int32 DAM3000M_RTD_PT100_385_N0_P100 = 0x22; // Pt100(385)热电阻    0℃～100℃
        public const Int32 DAM3000M_RTD_PT100_385_N0_P200 = 0x23; // Pt100(385)热电阻    0℃～200℃
        public const Int32 DAM3000M_RTD_PT100_385_N0_P600 = 0x24; // Pt100(385)热电阻    0℃～600℃
        public const Int32 DAM3000M_RTD_PT100_3916_N200_P850 = 0x25; // Pt100(3916)热电阻-200℃～850℃
        public const Int32 DAM3000M_RTD_PT100_3916_N100_P100 = 0x26; // Pt100(3916)热电阻-100℃～100℃
        public const Int32 DAM3000M_RTD_PT100_3916_N0_P100 = 0x27; // Pt100(3916)热电阻   0℃～100℃
        public const Int32 DAM3000M_RTD_PT100_3916_N0_P200 = 0x28; // Pt100(3916)热电阻   0℃～200℃
        public const Int32 DAM3000M_RTD_PT100_3916_N0_P600 = 0x29; // Pt100(3916)热电阻   0℃～600℃
        public const Int32 DAM3000M_RTD_PT1000 = 0x30; // Pt1000热电阻     -200℃～850℃
        public const Int32 DAM3000M_RTD_CU50 = 0x40; // Cu50热电阻        -50℃～150℃
        public const Int32 DAM3000M_RTD_CU100 = 0x41; // Cu100热电阻       -50℃～150℃
        public const Int32 DAM3000M_RTD_BA1 = 0x42; // BA1热电阻        -200℃～650℃
        public const Int32 DAM3000M_RTD_BA2 = 0x43; // BA2热电阻        -200℃～650℃
        public const Int32 DAM3000M_RTD_G53 = 0x44; // G53热电阻         -50℃～150℃
        public const Int32 DAM3000M_RTD_Ni50 = 0x45; // Ni50热电阻        100℃
        public const Int32 DAM3000M_RTD_Ni508 = 0x46; // Ni508热电阻         0℃～100℃
        public const Int32 DAM3000M_RTD_Ni1000 = 0x47; // Ni1000热电阻      -60℃～160℃

        // 模块量输出斜率类型	供DAM3000M_SetModeDA函数中的参数 lType 使用
        public const Int32 DAM3000M_SLOPE_IMMEDIATE = 0x00; // Immediate
        public const Int32 DAM3000M_SLOPE_POINT125 = 0x01; // 0.125 mA/S
        public const Int32 DAM3000M_SLOPE_POINT25 = 0x02; // 0.25  mA/S
        public const Int32 DAM3000M_SLOPE_POINT5 = 0x03; // 0.5  mA/S
        public const Int32 DAM3000M_SLOPE_1 = 0x04; // 1.0  mA/S
        public const Int32 DAM3000M_SLOPE_2 = 0x05; // 2.0  mA/S
        public const Int32 DAM3000M_SLOPE_4 = 0x06; // 4.0  mA/S
        public const Int32 DAM3000M_SLOPE_8 = 0x07; // 8.0  mA/S
        public const Int32 DAM3000M_SLOPE_16 = 0x08; // 16.0  mA/S
        public const Int32 DAM3000M_SLOPE_32 = 0x09; // 32.0  mA/S
        public const Int32 DAM3000M_SLOPE_64 = 0x0A; // 64.0  mA/S
        public const Int32 DAM3000M_SLOPE_128 = 0x0B; // 128.0  mA/S
        public const Int32 DAM3000M_SLOPE_256 = 0x0C; // 256.0  mA/S
        public const Int32 DAM3000M_SLOPE_512 = 0x0D; // 512.0  mA/S
        public const Int32 DAM3000M_SLOPE_1024 = 0x0E; // 1024.0  mA/S
        public const Int32 DAM3000M_SLOPE_2048 = 0x0F; // 2048.0  mA/S

        // DI计数方式 供DAM3000M_SetDeviceMode函数中的lMode参数使用
        public const Int32 DAM3000M_DI_MODE_DI = 0x00; // DI方式
        public const Int32 DAM3000M_DI_MODE_COUNT = 0x01; // 计数方式
        public const Int32 DAM3000M_DI_MODE_LATCH = 0x02; // 锁存方式

        // DI计数方式 供DAM3000M_SetDeviceMode函数中的lEdgeMode参数使用
        public const Int32 DAM3000M_DIR_FALLING = 0x00; // 下降沿
        public const Int32 DAM3000M_DIR_RISING = 0x01; // 上升沿

        //########################## 计数器 ###################################
        // 模块的工作模式 供DAM3000M_SetDevWorkMode函数中的lMode参数使用
        public const Int32 DAM3000M_WORKMODE_CNT = 0x00; // 计数器
        public const Int32 DAM3000M_WORKMODE_FREQ = 0x01; // 频率器

        // 计数器/频率的输入方式 供DAM3000M_PARA_CNT结构体中的lInputMode参数使用
        public const Int32 DAM3000M_UNISOLATED = 0x00; // 非隔离
        public const Int32 DAM3000M_ISOLATED = 0x01; // 隔离

        // 门槛值状态 供DAM3000M_PARA_CNT结构体中的GateSts参数使用
        public const Int32 DAM3000M_GATE_LOW = 0x00; // 门槛值为低电平
        public const Int32 DAM3000M_GATE_HIGH = 0x01; // 门槛值为高电平
        public const Int32 DAM3000M_GATE_NULL = 0x02; // 门槛值无效

        // 报警方式 供DAM3000M_CNT_ALARM结构体中的AlarmMode参数使用
        public const Int32 CNT_ALARM_MODE0 = 0x00; // 报警方式0	0通道-1通道上限
        public const Int32 CNT_ALARM_MODE1 = 0x01; // 报警方式1	0通道上限 / 上上限

        // 报警方式0使能 供DAM3000M_CNT_ALARM结构体中的EnableAlarm0 和 EnableAlarm1参数使用
        public const Int32 CNT_ALAMODE0_DISABLE = 0x00; // 报警方式0禁止报警
        public const Int32 CNT_ALAMODE0_ENABLE = 0x01; // 报警方式0允许报警

        // 报警方式1使能 供DAM3000M_CNT_ALARM结构体中的EnableAlarm0参数使用
        public const Int32 CNT_ALAMODE1_DISABLE = 0x00; // 报警方式1 计数器0 禁止报警
        public const Int32 CNT_ALAMODE1_INSTANT = 0x01; // 报警方式1 计数器0 瞬间报警允许
        public const Int32 CNT_ALAMODE1_LATCH = 0x02; // 报警方式1 计数器0 闭锁报警允许

        // 滤波状态使能 供DAM3000M_PARA_FILTER结构体中的bEnableFilter参数使用
        public const Int32 DAM3000M_FILTER_DISABLE = 0x00; // 禁止滤波
        public const Int32 DAM3000M_FILTER_ENABLE = 0x01; // 允许滤波
                                                          //-----------------------------------------------------

        //########################## 电量 ###################################
        public const Int32 DAM3000M_GET_I_RMS = 0x00; // 获得电流有效值
        public const Int32 DAM3000M_GET_V_RMS = 0x01; // 获得电压有效值
        public const Int32 DAM3000M_GET_POWER = 0x02; // 获得有功功率
        public const Int32 DAM3000M_GET_VAR = 0x03; // 获得无功功率
        public const Int32 DAM3000M_GET_VA = 0x04; // 获得视在功率
        public const Int32 DAM3000M_GET_WATTHR = 0x05; // 获得正相有功电度
        public const Int32 DAM3000M_GET_RWATTHR = 0x06; // 获得反相有功电度
        public const Int32 DAM3000M_GET_VARHR = 0x07; // 获得正相无功电度
        public const Int32 DAM3000M_GET_RVARHR = 0x08; // 获得反相无功电度
        public const Int32 DAM3000M_GET_PF = 0x09; // 获得功率因数
        public const Int32 DAM3000M_GET_FREQ = 0x0A; // 获得输入信号频率
        public const Int32 DAM3000M_GET_VAWATTHR = 0x0B; // 获得电度
        public const Int32 DAM3000M_GET_PHVOLTAGE = 0x0C; // 获得相电压


        // 数显表小数点位置  供DAM3000M_SetDecimalPoint和DAM3000M_GetDecimalPoint中使用###################################

        public const Int32 DAM3000M_DECPOINT_ABit = 0x00; // 小数点在个位
        public const Int32 DAM3000M_DECPOINT_Ten = 0x01; // 小数点在十位
        public const Int32 DAM3000M_DECPOINT_Hundred = 0x02; // 小数点在百位
        public const Int32 DAM3000M_DECPOINT_Thousand = 0x03; // 小数点在千位
        public const Int32 DAM3000M_DECPOINT_NULL = 0x04; // 无小数点


        // 串口号(以此类推) 供DAM3000M_CreateDevice使用，可根据自身需要扩充
        public const Int32 DAM3000M_COM1 = 0x01; // COM1
        public const Int32 DAM3000M_COM2 = 0x02; // COM2
        public const Int32 DAM3000M_COM3 = 0x03; // COM3
        public const Int32 DAM3000M_COM4 = 0x04; // COM4
        public const Int32 DAM3000M_COM5 = 0x05; // COM5
        public const Int32 DAM3000M_COM6 = 0x06; // COM1
        public const Int32 DAM3000M_COM7 = 0x07; // COM2
        public const Int32 DAM3000M_COM8 = 0x08; // COM3
        public const Int32 DAM3000M_COM9 = 0x09; // COM4
        public const Int32 DAM3000M_COM10 = 0x010; // COM5
        public const Int32 DAM3000M_COM23 = 0x023; // COM23
        // 波特率选择 供DAM3000M_SetDeviceInfo和DAM3000M_GetDeviceInfo中的PDAM3000M_DEVICE_INFO使用
        public const Int32 DAM3000M_BAUD_1200 = 0x00;
        public const Int32 DAM3000M_BAUD_2400 = 0x01;
        public const Int32 DAM3000M_BAUD_4800 = 0x02;
        public const Int32 DAM3000M_BAUD_9600 = 0x03;
        public const Int32 DAM3000M_BAUD_19200 = 0x04;
        public const Int32 DAM3000M_BAUD_38400 = 0x05;
        public const Int32 DAM3000M_BAUD_57600 = 0x06;
        public const Int32 DAM3000M_BAUD_115200 = 0x07;


        // 波特率选择 供DAM3000M_SetDeviceInfo和DAM3000M_GetDeviceInfo中的PDAM3000M_DEVICE_INFO(bParity)使用
        public const Int32 DAM3000M_PARITY_NONE = 0x00;
        public const Int32 DAM3000M_PARITY_EVEN = 0x01;
        public const Int32 DAM3000M_PARITY_ODD = 0x02;



        public const Int32 DAM3000M_DEFAULT_TIMEOUT = -1;
        //####################### 设备对象管理函数 #################################	
        [DllImport("DAM3000M_32.DLL")]
        public static extern IntPtr DAM3000M_CreateDevice(Int32 lPortNum);      // 创建设备对象
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_InitDevice(                     // 初始与模块之间的通信参数
                                                           IntPtr hDevice,  // 设备对象句柄
                                                           Int32 lBaud,     // 波特率
                                                           Int32 lParity,   // 校验方式
                                                           Int32 lTimeOut);// 超时时间，主要用于接收数据，如果为-1 则使用默认超时时间
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReleaseDevice(IntPtr hDevice);      // 释放设备对象 

        //################################### 模块信息取得/修改函数 ############################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDeviceInfo(                                      // 读取模块信息(类型、地址、波特率、校验)
                                                           IntPtr hDevice,                  // 设备对象句柄
                                                           Int32 lDeviceID,                 // 设备地址
                                                           ref DAM3000M_DEVICE_INFO pInfo); // 设备信息
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDeviceInfo(                                      // 修改模块信息(地址、波特率、校验)
                                                           IntPtr hDevice,                  // 设备对象句柄
                                                           Int32 lDeviceID,                 // 设备地址
                                                           ref DAM3000M_DEVICE_INFO Info);		// 设备信息
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDevLastError(                                    // 获得最后一个错误
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);                   // 模块地址

        //####################### AD数据读取函数 ###################################	
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadDeviceAD(                                       // 读取AD模拟量输入 
                                                            IntPtr hDevice,                 // 设备对象句柄	
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32[] lpADBuffer,                 // 接收AD数据的用户缓冲区 注意:lpADBuffer最好大于等于lLastChannel - lFirstChannel +1
                                                            Int32 lBufferSize,              // 数组lpADBuffer[]的大小
                                                            Int32 lFirstChannel,                // 首通道
                                                            Int32 lLastChannel);			    // 末通道
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetModeAD(                                          // 获得模拟量输入模式 
                                                            IntPtr hDevice,                 // 设备对象句柄	
                                                            Int32 lDeviceID,					// 模块地址
                                                            ref Int32 lpMode,                   // AD模式
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetModeAD(                                          // 设置AD输入模式 
                                                            IntPtr hDevice,                 // 设备对象句柄	
                                                            Int32 lDeviceID,					// 模块地址
                                                            Int32 lMode,                      // 通道号
                                                            Int32 lChannel);					// AD通道号 
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetGroundingAD(                                 // 获得通道接地模式(只对可软件配置单/双端输入模块有效)
                                                            IntPtr hDevice,                 // 设备对象句柄	
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpGrounding,              // AD通道接地模式
                                                            Int32 lChannel);                    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetGroundingAD(                                 // 设置通道接地模式(只对可软件配置单/双端输入模块有效)
                                                            IntPtr hDevice,                 // 设备对象句柄	
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lGrounding,                   // AD通道接地模式
                                                            Int32 lChannel);				    // 通道号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetLowLimitVal(                                 // 获得模拟量输入报警下限值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32[] lLowLimit,                  // 下限报警值
                                                            Int32 lFirstChannel,            // 首通道号
                                                            Int32 lLastChannel);			    // 末通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetHighLimitVal(                                    // 获得模拟量输入报警上限值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32[] lHighLimit,                 // 上限报警值
                                                            Int32 lFirstChannel,            // 首通道号
                                                            Int32 lLastChannel);			    // 末通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetLowLimitVal(                                 // 设置下限报警值
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32[] lLowVal,                    // 下限报警值
                                                            Int32 lFirstChannel,                // 首通道号
                                                            Int32 lLastChannel);			    // 末通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetHighLimitVal(                                    // 设置上限报警值
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32[] lHighVal,                   // 上限报警值
                                                            Int32 lFirstChannel,                // 首通道号
                                                            Int32 lLastChannel);			    // 末通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetAlarmPulse(                                  // 获得报警的电平
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpAlarmVal,               // 报警电平,0:低电平, 1:高电平
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetAlarmPulse(                                  // 设置模拟量输入报警电平
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lAlarmVal,                    // 报警电平,0:低电平, 1:高电平	
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetAlarmSts(                                        // 获得报警状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpAlarmSts,               // 报警状态
                                                            Int32 lChannel);				    // 读取通道
        [DllImport("DAM3000M_32.DLL")]
        //####################### DA数据读取函数 ###################################
        public static extern Int32 DAM3000M_GetDeviceDAVal(                                 // 回读DA输出值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpDAValue,            // DA输出当前值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_WriteDeviceDA(                                      // 设定单通道DA
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lDAData,                  // DA输出值
                                                            Int32 lChannel);      		    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetOutPutRangeDA(                                   // 读取模拟量输出量程
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpRange,              // 输出量程
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetOutPutRangeDA(                                   // 设置模拟量输出量程
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lRange,                       // 输出量程
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetPowerOnValueDA(                                  // 获得DA上电值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpPowerOnVal,         // 上电值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetPowerOnValueDA(                                  // 设置DA上电值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lPowerOnVal,              // 上电值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetSafeValueDA(                                 // 获得DA安全值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpSafeVal,                // 安全值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetSafeValueDA(                                 // 设置DA安全值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lSafeVal,                 // 安全值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetSlopeDA(                                         // 读模拟量输出斜率
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpSlopeType,          // 输出斜率类型
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetSlopeDA(                                     // 修改模拟量输出斜率
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lSlopeType,                   // 输出斜率类型
                                                            Int32 lChannel);                    // 通道号

        //####################### DI输入输出操作函数 ##############################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetModeDI(                                          // 设置数字量输入的工作模式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32[] lMode,                      // 输入的工作模式,0:DI模式,1:计数方式,2:锁存方式
                                                            Int32[] lEdgeMode,                  // 边沿方式,0:低电平,1:高电平
                                                            Int32 lFirstChannel,              // 首通道
                                                            Int32 lLastChannel);			    // 末通道 
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetModeDI(                                          // 设置数字量输入的工作模式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lMode,                        // 输入的工作模式,0:DI模式,1:计数方式,2:锁存方式
                                                            Int32 lEdgeMode,                    // 边沿方式,0:低电平,1:高电平
                                                            Int32 lChannel);				    // 通道号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDeviceDI(                                        // 读取开关量输入 
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_DI pDIPara,		// DI值
                                                            Int32 lBufferSize);                 // 通道大小
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StartDeviceDI(                                      // 启动DI计数
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StopDeviceDI(                                       // 停止DI计数
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetCNTDI(                                           // 读取DI计数器值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpCounterValue,       // 范围(0~65535)
                                                            Int32 lFirstChannel,              // 首通道
                                                            Int32 lLastChannel);              // 末通道				    

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetCNTDI(                                           // 设置DI计数器初始值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lInitValue,                   // 计数初值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StartLatch(                                     // 启动锁存
                                                            IntPtr hDevice,                 // 设备句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);                // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StopLatch(                                          // 停止锁存      
                                                            IntPtr hDevice,                 // 设备句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetLatchStatus(                                 // 读锁存状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lLatchType,					// 锁存类型，分为上升沿和下降沿锁存
                                                            ref DAM3000M_PARA_LATCH pLatchStatus,	// 通道大小
                                                            Int32 lBufferSize);
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ClearCNTVal(                                        // 清除计数值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ClearLatchStatus(                                   // 清除锁存状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);                    // 通道号

        //####################### DO数字量输出函数 ###################################	
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDeviceDO(                                        // 回读开关量输出
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                           ref DAM3000M_PARA_DO pDOPara);		// 当前DO输出值
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDeviceDO(                                        // 设置DO开关量输出值 
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Byte[] byDOSts,                 // 设置DO输出值
                                                            Int32 lFirstChannel,                // 首通道号
                                                            Int32 lLastChannel);                // 末通道号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetPowerOnValueDO(                              // 获取DO上电初始值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_DO pPowerOnPara);	// 上电值 
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetPowerOnValueDO(                                  // 设置DO上电初始值 
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_DO PowerOnPara);	// 上电值
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetSafeValueDO(                                 // 读DO安全值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_DO pDOSafePara);	// 安全值
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetSafeValueDO(                                 // 设置安全值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_DO DOSafePara);   // 安全值

        //#############################  计数器  ###################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetCounterMode(                                 // 对各个计数器进行参数设置
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_CNT pCNTPara,     // 基于各通道的计数器参数
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_InitCounterAlarm(                                   // 初始化报警的工作模式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_CNT_ALARM pCNTAlarm);	// 报警参数设置
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetCounterAlarmMode(                                // 设置计数器报警方式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lAlarmMode);				// 报警方式
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetCounterSts(                                      // 获得计数器设备硬件参数状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_CNT_STATUS pStsCNT,    // 返回值
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StartCounter(                                       // 启动计数器计数
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StopCounter(                                        // 停止计数器计数
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetCounterCurVal(                                   // 取得计数器当前值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 设备地址
                                                            ref UInt32 pCNTVal,             // 计数值
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetFreqCurVal(                                  // 取得频率器当前值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 设备地址
                                                            ref Int32 pFreqVal,             // 频率值
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ResetCounter(                                       // 计数器复位
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_InitCounterFilter(                              // 初始化滤波
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref DAM3000M_PARA_FILTER pFilter,   // 滤波参数
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_EnableFilter(                                       // 使能滤波状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 bEnable,                  // 使能滤波
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetCounterAlarmSts(                             // 获得DO及报警状态
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 设备地址
                                                            ref Int32 plEnableAlarm,            // 计数器报警状态
                                                            ref Int32 pbDO,                 // DO
                                                            Int32 lChannel);				// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetCounterDO(                       // 设置DO
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Byte[] byDOSts,                 // DO
                                                            Int32 lFirstChannel,                // 首通道号
                                                            Int32 lLastChannel);				// 末通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ClearAlarmSts(                                      // 清报警方式1报警输出
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);					// 设备地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetLEDCounterCH(                                    // 取得计数器LED显示通道
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 plChannel);             // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetLEDCounterCH(                                    // 设置计数器LED显示通道
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);                    // 通道号

        //#############################  电量模块  ###################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetEnergyVal(                                       // 获得电量值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32[] lValue,                 // 电量值
                                                            Int32 lAanlogType,              // 模拟量类型
                                                            Int32 lFirstChannel,            // 首通道
                                                            Int32 lLastChannel);			// 末通道
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ClrEnergyReg(                                       // 清能量寄存器
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lChannel);				// 通道
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetEnergyPerLSB(                                    // 获得能量单位
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpEnergyPerLSB);		// 能量单位
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetEnergyPerLSB(                                    // 设置能量单位
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lEnergyPerLSB);			// 能量单位
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetInputRange(                                  // 获得输入量程
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,					// 设备地址
                                                            ref Int32 lpInputRangeV,            // 电压输入量程
                                                            ref Int32 lpInputRangeI);    	// 电流输入量程			
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetInputRange(                                  // 设置输入量程
                                                            IntPtr hDevice,                 // 设备对象句
                                                            Int32 lDeviceID,                    // 设备地址
                                                            Int32 lInputRangeV,             // 电压输入量程
                                                            Int32 lInputRangeI);				// 电流输入量程
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetEvrmTemp(                                        // 获得环境温度
                                                            IntPtr hDevice,                 // 设备对象句
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpEvrmTemp,               // 温度
                                                            Int32 lChannel);				    // 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetEvrmHum(                                     // 获得环境湿度
                                                            IntPtr hDevice,                 // 设备对象句
                                                            Int32 lDeviceID,                    // 设备地址
                                                            ref Int32 lpEvrmHum,                // 湿度		
                                                            Int32 lChannel);                    // 通道号


        //##################################### 看门狗 ################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_HostIsOK(IntPtr hDevice);			                // 下位机无返回信息
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_EnableWatchdog(                                 // 打开主看门狗(先设置超时间隔，再使能看门狗)
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);	                // 模块地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_CloseWatchdog(                                  // 禁止看门狗工作
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);	                // 模块地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetWatchdogStatus(                              // 读取主看门狗的状态(S = 1, Host is down; S = 0 OK)
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpWatchdogStatus);		// 看门狗状态
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ResetWatchdogStatus(                                // Func: 复位主看门狗的状态(S = 0)
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);					// 模块地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetWatchdogTimeoutVal(                          // 取得看门狗设置的时间间隔
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpInterval);			// 时间间隔
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetWatchdogTimeoutVal(                          // 设置看门狗设置的时间间隔
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lInterval);                   // 时间间隔

        // ##################################### DIGIT LED 设置函数 #################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDLedMode(                                        // 获得显示模式请求
                                                            IntPtr hDevice,                     // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpDispMode);				// 显示模式 =0x00：温度格式,=0x01:欧姆值
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDLedMode(                                        // 修改显示模式请求
                                                            IntPtr hDevice,                     // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lDispMode);					// 显示模式 =0x01：温度格式,=0x02:欧姆值
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDLedDispChannel(                             // 获得LED显示通道号
                                                            IntPtr hDevice,                     // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            ref Int32 lpChannel);				// 通道号,lpChannel = =0xff:主机控制显示
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDLedDispChannel(                             // 设置LED显示通道号
                                                            IntPtr hDevice,                     // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lChannel);				    // 通道号,lpChannel = =0xff:主机控制显示
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDLedValue(                                       // 主机控制显示值
                                                            IntPtr hDevice,                     // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            String strWriteBuf,                 // 显示的字符串
                                                            Int32 llength);                 // 数据长度
                                                                                            //####################### 输入输出任意二进制字符 ###########################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_WriteDeviceChar(                                    // 直接写设备
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            ref String strWriteBuf,         // 写的数据
                                                            Int32 llength,                  // 数据长度
                                                            Int32 timeout);                 // 超时范围(mS)
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadDeviceChar(                                 // 直接读设备
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            ref String strReadBuf,              // 读取的数据
                                                            Int32 llength,                  // 数据长度
                                                            Int32 timeout);                 // 超时范围(mS)


        //###########################　模块信息确认函数  #################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 InitCheckInfo(
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,
                                                            UInt32 dwNum);
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 ReadCheckInfo(
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,
                                                            Int32 lIndex,
                                                            ref Byte byEncrypt);

        //####################################### 辅助函数 ####################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_AdjustSlopeVal(                                 // 微调当前补偿斜率
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 模块地址
                                                            Int32 lAdjustVal,               // 微调值
                                                            Int32 lChannel);					// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_StoreSlopeVal(                                      // 设置当前值为输出补偿斜率
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 模块地址
                                                            Int32 lChannel);					// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetFaultSlopeVal(                                   // 设定补偿斜率为默认值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                // 模块地址
                                                            Int32 lChannel);					// 通道号	=0xFF为所有通道恢复
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetZeroRepair(                                      // 设置零点偏移补偿
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID,                    // 模块地址
                                                            Int32 lZeroRepair,              // 零点值
                                                            Int32 lChannel);					// 通道号
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDevTestMode(                                     // 设置模块进入测试模式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID);			    // 模块地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ResetModule(                                        // 模块软复位
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDeviceID); 				// 模块地址
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetEnvironmentTemp(                             // 取得环境温度(为取热电偶值作准备)
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,
                                                            ref Single lpETemprt);
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetAdjustTemp(                                      // 取得环境温度(为取热电偶值作准备)
                                                            IntPtr hDevice,
                                                            Int32 lDeviceID,
                                                            Byte lETemprt);


        //####################################### 测温操作函数 ####################################

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadMeasuringValue(             // 读取测量值 
                                    IntPtr hDevice,                 // 设备对象句柄	
                                    Int32 lDeviceID,                    // 模块地址
                                    UInt16[] lpADBuffer);               // 接收数据的用户缓冲区128

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_TempResetModule(                    // 复位测温模块 
                                    IntPtr hDevice,                 // 设备对象句柄	
                                    Int32 lDeviceID);                   // 模块地址

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetSensorSerialNumber(              // 修改传感器编号
                                    IntPtr hDevice,                 // 设备对象句柄
                                    Int32 lDeviceID,                    // 设备地址
                                    Byte bChannel,                  // 通道号
                                    Byte bSequenceNumber,           // 通道内顺序号
                                    Byte bNewNumber,                    // 新编号
                                    Boolean bAuto);                     // 是否自动编号  FALSE手动编号 TURE自动编号(通道号 通道内顺序号 新编号 参数不起作用)

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetSensorPara(                      // 读取传感器参数
                                    IntPtr hDevice,                 // 设备对象句柄
                                    Int32 lDeviceID,                    // 设备地址
                                    DAM3000M_SENSOR_PARA[] pInfo);  // 传感器参数





        //####################################### Modus 基本功能操作函数 ####################################

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadCoils(                          // 读继电器状态
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    int addr,
                                    int len,
                                    Byte[] bCoilsFlag);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadDiscretes(                      // 读开关量输入
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    int addr,
                                    int len,
                                    Byte[] bDIState);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadMultiRegs(                      // 读保持寄存器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    int addr,
                                    int len,
                                    Byte[] buf);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadInputRegs(                      // 读输入寄存器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    int addr,
                                    int len,
                                    Byte[] buf);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_WriteCoil(                          // 设置单个继电器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    int addr,
                                    Byte status);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_WriteSingleReg(                 // 设置单个保持寄存器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    Int32 addr,
                                    Int16 val);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ForceMultiCoils(                    // 设置多个继电器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    Int32 addr,
                                    Int32 len,
                                    Byte[] bDOState);

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_WriteMultiRegs(                 // 设置多个保持寄存器
                                    IntPtr hDevice,
                                    Int32 lDeviceID,
                                    Int32 addr,
                                    Int32 len,
                                    Byte[] buf);





        //####################################### 数码管显示 ####################################
        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_DisplayData(                    // 单显部分 显示数据
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,                // 模块地址
                                    UInt16 wData);                  // 数据

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_DisplaySpecialSymbols(          // 单显部分 特殊符号
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    UInt16 wSymbols);               // 符号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadData(                       // 单显部分 读数据
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    ref UInt16 pwData);             // 数据

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadSpecialSymbols(         // 单显部分 读特殊符号
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    ref UInt16 pwSymbols);              // 符号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_DisplayDataSymbols(         // 混显部分 显示数据及特殊符号
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    UInt16 wData,					// 数据
                                    UInt16 wSymbols);               // 符号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_ReadDataSymbols(                // 混显部分 读数据及特殊符号
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    ref UInt16 pwData,					// 数据
                                    ref UInt16 pwSymbols);              // 符号

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_SetDecimalPoint(                // 设置小数点位置
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    Int32 lDecimalPoint);           // 小数点位置

        [DllImport("DAM3000M_32.DLL")]
        public static extern Int32 DAM3000M_GetDecimalPoint(                // 读取小数点位置
                                    IntPtr hDevice,             // 设备对象句柄
                                    Int32 lDeviceID,				// 模块地址
                                    ref Int32 plDecimalPoint);		// 小数点位置



    }
    public class DAME3000
    {
        // 模拟量输入类型(电压类型) 供DAME3000_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000_VOLT_N15_P15 = 0x01;	//  -15～+15mV
        public const Int32 DAME3000_VOLT_N50_P50 = 0x02;	//  -50～+50mV
        public const Int32 DAME3000_VOLT_N100_P100 = 0x03;	// -100～+100mV
        public const Int32 DAME3000_VOLT_N150_P150 = 0x04;	// -150～+150mV
        public const Int32 DAME3000_VOLT_N500_P500 = 0x05;	// -500～+500mV
        public const Int32 DAME3000_VOLT_N1_P1 = 0x06;	//   -1～+1V
        public const Int32 DAME3000_VOLT_N25_P25 = 0x07;	// -2.5～+2.5V
        public const Int32 DAME3000_VOLT_N5_P5 = 0x08;	//   -5～+5V
        public const Int32 DAME3000_VOLT_N10_P10 = 0x09;	//  -10～+10V
        public const Int32 DAME3000_VOLT_N0_P5 = 0x0D;	//    0～+5V
        public const Int32 DAME3000_VOLT_N0_P10 = 0x0E;	//    0～+10V
        public const Int32 DAME3000_VOLT_N0_P25 = 0x0F;	//    0～+2.5V

        // 模拟量输入类型(电流类型) 供DAME3000_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000_CUR_N0_P10 = 0x00;	//   0～10mA
        public const Int32 DAME3000_CUR_N20_P20 = 0x0A;	// -20～+20mA
        public const Int32 DAME3000_CUR_N0_P20 = 0x0B;	//   0～20mA
        public const Int32 DAME3000_CUR_N4_P20 = 0x0C;	//   4～20mA

        // 模拟量输入类型(热电阻类型) 供DAME3000_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000_RTD_CU50 = 0x40;	// Cu50热电阻        -50℃～150℃
        public const Int32 DAME3000_RTD_CU100 = 0x41;	// Cu100热电阻       -50℃～150℃
        public const Int32 DAME3000_RTD_PT100_385_N200_P850 = 0x20;	// Pt100(385)热电阻 -200℃～850℃
        public const Int32 DAME3000_RTD_PT100_385_N100_P100 = 0x21;	// Pt100(385)热电阻 -100℃～100℃
        public const Int32 DAME3000_RTD_PT100_385_N0_P100 = 0x22;	// Pt100(385)热电阻    0℃～100℃
        public const Int32 DAME3000_RTD_PT100_385_N0_P200 = 0x23;	// Pt100(385)热电阻    0℃～200℃
        public const Int32 DAME3000_RTD_PT100_385_N0_P600 = 0x24;	// Pt100(385)热电阻    0℃～600℃
        public const Int32 DAME3000_RTD_PT100_3916_N200_P850 = 0x25;	// Pt100(3916)热电阻-200℃～850℃
        public const Int32 DAME3000_RTD_PT100_3916_N100_P100 = 0x26;	// Pt100(3916)热电阻-100℃～100℃
        public const Int32 DAME3000_RTD_PT100_3916_N0_P100 = 0x27;	// Pt100(3916)热电阻   0℃～100℃
        public const Int32 DAME3000_RTD_PT100_3916_N0_P200 = 0x28;	// Pt100(3916)热电阻   0℃～200℃
        public const Int32 DAME3000_RTD_PT100_3916_N0_P600 = 0x29;	// Pt100(3916)热电阻   0℃～600℃
        public const Int32 DAME3000_RTD_PT1000 = 0x30;	// Pt1000热电阻     -200℃～850℃
        public const Int32 DAME3000_RTD_BA1 = 0x42;	// BA1热电阻        -200℃～650℃
        public const Int32 DAME3000_RTD_BA2 = 0x43;	// BA2热电阻        -200℃～650℃
        public const Int32 DAME3000_RTD_G53 = 0x44;	// G53热电阻         -50℃～150℃
        public const Int32 DAME3000_RTD_Ni50 = 0x45;	// Ni50热电阻        100℃～
        public const Int32 DAME3000_RTD_Ni508 = 0x46;	// Ni508热电阻         0℃～100℃
        public const Int32 DAME3000_RTD_Ni1000 = 0x47;	// Ni1000热电阻      -60℃～160℃

        // 模拟量输入类型(热电偶类型) 供DAME3000_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000_THERMOCOUPLE_J = 0x10;	// J型热电偶			0℃～1200℃
        public const Int32 DAME3000_THERMOCOUPLE_K = 0x11;	// K型热电偶			0℃～1300℃
        public const Int32 DAME3000_THERMOCOUPLE_T = 0x12;	// T型热电偶			0℃～400℃
        public const Int32 DAME3000_THERMOCOUPLE_E = 0x13;	// E型热电偶			0℃～1000℃
        public const Int32 DAME3000_THERMOCOUPLE_R = 0x14;	// R型热电偶		  500℃～1700℃
        public const Int32 DAME3000_THERMOCOUPLE_S = 0x15;	// S型热电偶		  500℃～1768℃
        public const Int32 DAME3000_THERMOCOUPLE_B = 0x16;	// B型热电偶		  500℃～1800℃
        public const Int32 DAME3000_THERMOCOUPLE_N = 0x17;	// N型热电偶			0℃～1300℃
        public const Int32 DAME3000_THERMOCOUPLE_C = 0x18;	// C型热电偶			0℃～2090℃

        // 数字量输出类型使用
        public const Int32 DAME3000_OUTPUT_TYPE_DIGIT = 0;		// 数字量输出
        public const Int32 DAME3000_OUTPUT_TYPE_PULSE = 1;	    // 脉冲输出

        // 数字量输入类型 供DAME3000_SetModeCNT函数中的nADMode参数使用
        public const Int32 DAME3000_DI_MODE_CNT_RISING = 1;		// 上升沿计数
        public const Int32 DAME3000_DI_MODE_CNT_FALLING = 0;		// 下降沿计数
        // ****************** 计数器参数配置结构体 ******************************
        public struct DAME3000_CFG_CH_CNT			// 基于各通道的计数器参数结构体
        {
            public Int32 WorkMode;          // 计数器/频率工作模式
            public Int32 FreqGateTime;      // 频率器计数更新时间s
            public Int32 InputMode;         // 计数器/频率输入方式	0: 非隔离	1: 隔离	TTL/Photo
            public Int32 PresetValCNT;      // 计数器初始值		??计数器事先调整值
            public UInt32 MaxValCNT;            // 计数器最大值
            public Int32 Gate;				// 门槛值状态(计数模式)
        }

        public struct DAME3000_CNT_ALARM
        {
            public Int32 AlarmForm;         // 报警方式	
            public Int32 EnableAlarm0;      // 0通道报警使能
            public Int32 EnableAlarm1;      // 1通道报警使能
            public Int32 AlarmVal0;         // 0通道报警值
            public Int32 AlarmVal1;         // 1通道报警值
            public Int32 AlarmValHiHi;		// 报警方式1上上限(Hi-Hi)报警值	
        }

        public struct DAME3000_INITVAL_FILTER		// 用于计数器滤波的参数结构体
        {
            public Single TouchHighVolt;	// 设置触发高电平(非隔离输入)
            public Single TouchLowVolt;     // 设置触发低电平(非隔离输入)
            public Int32 MinSigWidHigh;     // 高电平最小输入信号宽度
            public Int32 MinSigWidLow;		// 低电平最小输入信号宽度
            public Int32 bEnableFilter;		// 使能滤波
        }


        public struct DAME3000_MODE_LED			// LED参数结构体
        {
            public Int32 LEDMode;           // LED显示模式
            public Single LEDVal;			// LED输出值
        }


        public struct DAME3000_STATUS_CNT			// 计数器硬件参数状态结构体
        {
            public Int32 WorkMode;			// 获得计数器/频率工作模式
            public Int32 FreqBuildTime;		// 获得频率器计数更新时间 建立时间
            public Int32 InputMode;			// 获得计数器/频率输入方式	0: 非隔离	1: 隔离
            public Int32 bCNTSts;			// 获得计数器的状态
            public Int32 FilterSts;			// 获得计数器的滤波器状态
            public Int32 MinSigWidHigh;		// 获得高电平最小输入信号宽度
            public Int32 MinSigWidLow;		// 获得低电平最小输入信号宽度
            public Single TouchHighVolt;	// 获得触发高电平(非隔离输入)
            public Single TouchLowVolt;		// 获得触发低电平(非隔离输入)
            public Int32 Gate;				// 获得门槛值设置状态(计数模式)
            public UInt32 MaxValCNT;			// 获得计数器最大值
            public Int32 PresetValCNT;		// 获得计数器初始值
            public Int32 bOverFlowSts;		// 获得计数器溢出状态
            public Int32 AlarmForm;			// 获得计数器报警方式
            public Int32 EnableAlarm0;		// 获得计数器0报警使能状态
            public Int32 EnableAlarm1;		// 获得计数器1报警使能状态
            public Int32 AlarmVal0;			// 获得0通道报警值
            public Int32 AlarmVal1;			// 获得1通道报警值
            public Int32 AlarmValHiHi;		// 获得报警方式1上上限(Hi-Hi)报警值
            public Int32 DO;				// 获得D/O	 0 开 1 关
            public Int32 D1;				// 获得D/O	
        }
        //########################## 计数器 ###################################
        // 模块的工作模式 供DAME3000_SetDevWorkMode函数中的lMode参数使用
        public const Int32 DAME3000_WORKMODE_CNT = 0x00; // 计数器
        public const Int32 DAME3000_WORKMODE_FRE = 0x01; // 频率器

        // 计数器/频率的输入方式 信号模式 供DAME3000_SetInputMode函数中的lInputMode参数使用
        public const Int32 DAME3000_UNISOLATED = 0x00; // 非隔离
        public const Int32 DAME3000_ISOLATED = 0x01; // 隔离

        // 门槛值状态
        public const Int32 DAME3000_GATE_LOW = 0x00; // 门槛值为低电平
        public const Int32 DAME3000_GATE_HIGH = 0x01; // 门槛值为高电平
        public const Int32 DAME3000_GATE_UN = 0x02; // 门槛值无效

        // 报警方式
        public const Int32 CNT_ALARM_FORM0 = 0x00; // 报警方式0
        public const Int32 CNT_ALARM_FORM1 = 0x01; // 报警方式1

        // 报警方式0使能
        public const Int32 CNT_ALAFORM0_DISEN = 0x00; // 报警方式0禁止报警
        public const Int32 CNT_ALAFORM1_EN = 0x01; // 报警方式0允许报警

        // 报警方式1使能
        public const Int32 CNT_ALAFORM1_DISEN = 0x00; // 报警方式1 计数器0 禁止报警
        public const Int32 CNT_ALAFORM1_MOMENT = 0x01; // 报警方式1 计数器0 瞬间报警允许
        public const Int32 CNT_ALAFORM1_LATCH = 0x02; // 报警方式1 计数器0 闭锁报警允许

        // 滤波器状态使能
        public const Int32 DAME3000_DISEN_FILTER = 0x00; // 禁止滤波器
        public const Int32 DAME3000_EN_FILTER = 0x01; // 允许滤波器

        // LED显示模式
        public const Int32 DAME3000_LED_MODE_CNT0 = 0x00; // CNT0
        public const Int32 DAME3000_LED_MODE_CNT1 = 0x01; // CNT1
        public const Int32 DAME3000_LED_MODE_USEROUT = 0x02; // 用户输出

        //-----------------------------------------------------
        // D/O报警状态 
        // 报警方式0
        public const Int32 DAME3000_CNT0OFF_CNT1OFF = 0x00; // 计数器0 禁止报警，计数器1 禁止报警
        public const Int32 DAME3000_CNT0ON_CNT1OFF = 0x01; // 计数器0 允许报警，计数器1 禁止报警
        public const Int32 DAME3000_CNT0OFF_CNT1ON = 0x02; // 计数器0 禁止报警，计数器1 允许报警
        public const Int32 DAME3000_CNT0ON_CNT1ON = 0x03; // 计数器0 允许报警，计数器1 允许报警
        // 报警方式1
        public const Int32 DAME3000_CNT0_OFF = 0x00; // 计数器0 禁止报警
        public const Int32 DAME3000_CNT0_MEM_ON = 0x01; // 计数器0 瞬间报警允许
        public const Int32 DAME3000_CNT0_LATCH_ON = 0x02; // 计数器0 闭锁报警允许
        // 设备网络信息
        public struct DEVICE_NET_INFO
        {
            public SByte szIP0;					// IP地址, // IP地址, "192.168.2.70"
            public SByte szIP1;
            public SByte szIP2;
            public SByte szIP3;
            public SByte szIP4;
            public SByte szIP5;
            public SByte szIP6;
            public SByte szIP7;
            public SByte szIP8;
            public SByte szIP9;
            public SByte szIP10;
            public SByte szIP11;
            public SByte szIP12;
            public SByte szIP13;
            public SByte szIP14;
            public SByte szIP15;

            public SByte SubnetMask0;				// 子网掩码, "255.255.255.255"
            public SByte SubnetMask1;
            public SByte SubnetMask2;
            public SByte SubnetMask3;
            public SByte SubnetMask4;
            public SByte SubnetMask5;
            public SByte SubnetMask6;
            public SByte SubnetMask7;
            public SByte SubnetMask8;
            public SByte SubnetMask9;
            public SByte SubnetMask10;
            public SByte SubnetMask11;
            public SByte SubnetMask12;
            public SByte SubnetMask13;
            public SByte SubnetMask14;
            public SByte SubnetMask15;

            public SByte Gateway0;				// 网关, "192.168.2.1"
            public SByte Gateway1;
            public SByte Gateway2;
            public SByte Gateway3;
            public SByte Gateway4;
            public SByte Gateway5;
            public SByte Gateway6;
            public SByte Gateway7;
            public SByte Gateway8;
            public SByte Gateway9;
            public SByte Gateway10;
            public SByte Gateway11;
            public SByte Gateway12;
            public SByte Gateway13;
            public SByte Gateway14;
            public SByte Gateway15;

            public SByte MAC0;					// 网卡物理地址,  "00-01-02-03-04-05",用户一般不可修改
            public SByte MAC1;
            public SByte MAC2;
            public SByte MAC3;
            public SByte MAC4;
            public SByte MAC5;
            public SByte MAC6;
            public SByte MAC7;
            public SByte MAC8;
            public SByte MAC9;
            public SByte MAC10;
            public SByte MAC11;
            public SByte MAC12;
            public SByte MAC13;
            public SByte MAC14;
            public SByte MAC15;
            public SByte MAC16;
            public SByte MAC17;
            public SByte MAC18;
            public SByte MAC19;

            public Int32 lTCPPort;              // TCP端口号
            public Int32 lHTTPPort;             // HTTP端口号

            public Int32 lUDPPort;                  // UDP端口号
            public Int32 lMode;                     // 连接模式(0: 静态模式  1: DHCP动态模式)
            public SByte chDevName0;				// Device self name
            public SByte chDevName1;
            public SByte chDevName2;
            public SByte chDevName3;
            public SByte chDevName4;
            public SByte chDevName5;
            public SByte chDevName6;
            public SByte chDevName7;
            public SByte chDevName8;
            public SByte chDevName9;
            public SByte chDevName10;
            public SByte chDevName11;
            public SByte chDevName12;
            public SByte chDevName13;
            public SByte chDevName14;
            public SByte chDevName15;
            public SByte chDevName16;
            public SByte chDevName17;
            public SByte chDevName18;
            public SByte chDevName19;
            public SByte chDevName20;
            public SByte chDevName21;
            public SByte chDevName22;
            public SByte chDevName23;
            public SByte chDevName24;
            public SByte chDevName25;
            public SByte chDevName26;
            public SByte chDevName27;
            public SByte chDevName28;
            public SByte chDevName29;
            public SByte chDevName30;
            public SByte chDevName31;
        }
        public struct DEVICE_NET_INFO_Test
        {
            [MarshalAs(UnmanagedType.LPStr, SizeConst = 16, ArraySubType = UnmanagedType.Struct)]
            public SByte[] szIP;					// IP地址, // IP地址, "192.168.2.70"

            [MarshalAs(UnmanagedType.LPStr, SizeConst = 16, ArraySubType = UnmanagedType.Struct)]
            public SByte[] SubnetMask;				// 子网掩码, "255.255.255.255"

            [MarshalAs(UnmanagedType.LPStr, SizeConst = 16, ArraySubType = UnmanagedType.Struct)]
            public SByte[] Gateway;				// 网关, "192.168.2.1"

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20, ArraySubType = UnmanagedType.Struct)]
            public SByte[] MAC;					// 网卡物理地址,  "00-01-02-03-04-05",用户一般不可修改

            public Int32 lTCPPort;				// TCP端口号
            public Int32 lHTTPPort;				// HTTP端口号
        }
        //####################### 设备对象管理函数 #################################

        [DllImport("DAME3000_32.dll")]
        public static extern IntPtr DAME3000_CreateDevice(                              // 创建设备
                                                            String szIP,				// 设备IP(如"192.168.1.2")
                                                            Int32 lPort,				// TCP端口
                                                            Int32 lSendTimeout,		    // 发送数据的超时间隔 
                                                            Int32 lRcvTimeout);		    // 接收数据的超时间隔																	  
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ReleaseDevice(IntPtr hDevice);	            // 释放设备对象
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDeviceVersion(                           // 取得设备版本信息
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] szVersion);		    // 设备版本信息
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetNetworkConfig(                           // 获得设备的网络配置信息
                                                            IntPtr hDevice,         // 设备句柄
                                                            ref DEVICE_NET_INFO pNetInfo); // 网络配置信息
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetNetworkConfig(                           // 设置设备的网络配置信息
                                                            IntPtr hDevice,         // 设备句柄
                                                            ref DEVICE_NET_INFO NetInfo);// 网络配置信息
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SaveIPAddress(String szIP);	            // 保存IP到注册表
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_LoadIPAddress(String szIP);	            // 载入IP到应用程序

        //################################### AD 函数 ####################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ReadDeviceAD(                               // 获得模拟量输入值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lADValue,           // 返回的AD数据
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetModeAD(                                  // 获得模拟量输入模式
                                                            IntPtr hDevice,			    // 设备句柄
                                                            ref Int32 lADMode,			// 返回的各个通道的AD模式
                                                            Int32 lFirstChannel,		// 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetModeAD(                                  // 设置模拟量输入模式
                                                            IntPtr hDevice,			    // 设备句柄
                                                            ref Int32 lADMode,			// 设置的AD模式
                                                            Int32 lFirstChannel,		// 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetLowLimitVal(                             // 设置下限报警值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lLowVal,            // 下限报警值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetLowLimitVal(                             // 获得报警下限值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lLowLimit,          // 获得的下限值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetHighLimitVal(                            // 设置上限报警值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lHighVal,           // 报警上限值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetHighLimitVal(                            // 获得报警上限值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lHighLimit,         // 报警上限值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetAlarmPulse(                              // 报警输出值
                                                            IntPtr hDevice,         // 设备句柄
                                                            ref Int32 lpAlarmValue);	// 报警输出电平
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetAlarmPulse(                              // 设置模拟量输入报警电平
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lAlarmValue);		// 报警输出电平
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetAlarmSts(                                // 获得报警状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lStatus,            // 报警状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号

        //################################### DA 函数 ####################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDeviceDA(                                // 回读DA输出值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            ref Int32 lpDAValue,      // DA输出当前值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_WriteDeviceDA(                              // 设定单通道DA
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lDAData,          // DA输出值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetModeDA(                                  // 读取模拟量输出类型
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            ref Int32 lpMode,           // 输出模式
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetModeDA(                                  // 设置模拟量输出类型
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lMode,                // 输出模式
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetPowerOnValueDA(                          // 获得DA上电值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            ref Int32 lpPowerOnVal,   // 上电值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetPowerOnValueDA(                          // 设置DA上电值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lPowerOnVal,      // 上电值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetSafeValueDA(                             // 获得DA安全值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            ref Int32 lpSafeVal,      // 安全值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetSafeValueDA(                             // 设置DA安全值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lSafeVal,         // 安全值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetSlopeDA(                                 // 读模拟量输出斜率
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            ref Int32 lpSlopeType,    // 输出斜率类型
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetSlopeDA(                                 // 修改模拟量输出斜率
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lSlopeType,           // 输出斜率类型
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetAdjustValDA(                             // 微调模拟量输出值
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 lAdjustVal,           // 微调值
                                                            Int32 lOutType,         // 输出类型,0:电流,1:电压
                                                            Int32 lChannel);			// 通道号

        //################################### DI 函数 ####################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDeviceDI(                                // 获得DI值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byDIStatus,          // DI状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDeviceCNT(                               // 获得计数值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lCurrentVal,        // 当前计数值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDeviceCNT(                               // 设置计数初值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lInitVal,           // 计数初值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetModeCNT(                                 // 获得计数方式
                                                            IntPtr hDevice,         // 设备句柄
                                                            ref Int32 lpCNTMode,      // 计数方式
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetModeCNT(                                 // 设置计数模式 1:为上升，0:为下降沿
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lCNTMode,         // 计数方式
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StartDeviceCNT(                             // 开始计数
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StopDeviceCNT(                              // 停止计数
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetEnableStsCNT(                            // 获得计数使能状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byCNTStatus,     // 计数使能状态
                                                            Int32 lCount);			// 通道个数
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetLatchEnableSts(                          // 获得锁存使能状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byLatchStatus,       // 锁存状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StartLatch(                                 // 启动锁存
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StopLatch(                                  // 停止锁存
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetLowLatchSts(                             // 获得下降沿锁存状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byLowLatchSts,       // 下降沿锁存状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetHiLatchSts(                              // 获得上升沿锁存状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byHiLatchSts,        // 上升沿锁存状态
                                                            Int32 lFirstChannel,        // 起始通道
                                                            Int32 lCount);          // 通道号

        //################################### DO 函数 ####################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDeviceDO(                                // 获得当前数字量输出
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byDOSts,         // DO状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDeviceDO(                                // 设置DO输出值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byDOSts,         // 设置DO输出值
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDevicePulse(                             // 获得脉冲输出宽度
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32[] lLowWidth,          // 低电平
                                                            Int32[] lHighWidth,         // 高电平
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDevicePulse(                             // 设置DO脉冲输出占空比
                                                            IntPtr hDevice,         // 设备句柄
                                                            ref Int32 lLowWidth,            // 脉冲输出低电平宽度
                                                            ref Int32 lHighWidth,           // 脉冲输出高电平宽度	
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetPulseEnableSts(                          // 获得脉冲使能状态
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byPulseStatus,       // 脉冲输出使能状态
                                                            Int32 lFirstChannel,        // 首通道号
                                                            Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StartDevicePulse(                           // 开始数字脉冲输出
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StopDevicePulse(                            // 停止数字脉冲输出
                                                            IntPtr hDevice,         // 设备句柄
                                                            Int32 lChannel);			// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetSafeValueDO(                             // 设置DO安全值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] bySafeVal,           // 安全值
                                                            Int32 lLength);			// 等于数组bySafeVal的长度
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetSafeValueDO(                             // 获得DO安全值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] bySafeVal,           // 安全值	
                                                            Int32 lLength);			// 等于数组bySafeVal的长度
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetPowerOnValueDO(                          // 设置DO上电值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byPowerOnVal,        // 上电值
                                                            Int32 lLength);			// 等于数组byPowerOnVal的长度
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetPowerOnValueDO(                          // 获取DO上电初始值
                                                            IntPtr hDevice,         // 设备句柄
                                                            Byte[] byPowerOnVal,        // 上电值
                                                            Int32 lLength);			// 等于数组byPowerOnVal的长度

        //#############################  计数器  ###################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetCounterMode(                             // 对各个计数器进行参数设置
                                                              IntPtr hDevice,           // 设备对象句柄
                                                              ref DAME3000_CFG_CH_CNT pCfgChCNT,// 基于各通道的计数器参数
                                                              Int32 lChannel);          // 通道号

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_InitCounterAlarm(                                   // 初始化报警的工作模式
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            ref DAME3000_CNT_ALARM pCNTAlarm);  // 报警参数设置

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetCounterAlarmMode(                                    // 设置报警
                                                                IntPtr hDevice,	                    // 设备对象句柄
                                                                ref DAME3000_CNT_ALARM pCNTAlarm);  // 报警参数设置
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetAlarmFormCNT(                            // 设置计数器报警方式
                                                                IntPtr hDevice,     // 设备对象句柄
                                                                Int32 lAlarmForm);	// 报警方式
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetCounterSts(                                          // 获得计数器设备硬件参数状态
                                                                IntPtr hDevice,                 // 设备对象句柄
                                                                ref DAME3000_STATUS_CNT pStsCNT,    // 返回值
                                                                Int32 lChannel);		            // 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StartCounter(                              // 启动计数器计数
                                                                IntPtr hDevice,     // 设备对象句柄
                                                                Int32 lChannel);		// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_StopCounter(                               // 停止计数器计数
                                                                IntPtr hDevice,     // 设备对象句柄
                                                                Int32 lChannel);		// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetCounterCurVal(                           // 取得计数器当前值
                                                                IntPtr hDevice,         // 设备对象句柄
                                                                ref Int32 pCNTVal,      // 计数值
                                                                Int32 lChannel);		// 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetFreqCurVal(                              // 取得频率器当前值
                                                                IntPtr hDevice,         // 设备对象句柄
                                                                ref Int32 pFreqVal, // 频率值
                                                                Int32 lChannel);		// 通道号

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ResetCounter(                              // 计数器值复位                        
                                                            IntPtr hDevice,     // 设备对象句柄
                                                            Int32 lChannel);                // 通道号

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ResetAll(							        // 计数器设备恢复为出厂设置
                                                        IntPtr hDevice);				// 设备对象句柄

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_InitCounterFilter(                                          // 初始化滤波
                                                                IntPtr hDevice,                     // 设备对象句柄
                                                                ref DAME3000_INITVAL_FILTER pFilter,    // 滤波参数
                                                                Int32 lChannel);				        // 通道号
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_EnableFilter(                           // 使能滤波器状态
                                                            IntPtr hDevice,         // 设备对象句柄
                                                            Int32 bEnable,      // 使能滤波器
                                                            Int32 lChannel);        // 通道号


        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetAlarmDO(                         // 设置报警开关量
                                                            IntPtr hDevice,     // 设备对象句柄
                                                            Int32 bDO,          // DO
                                                            Int32 lChannel);    // 通道号

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetCounterAlarmSts(                             // 获得DO及报警状态
                                                                    IntPtr hDevice,         // 设备对象句柄
                                                                    ref Int32 plEnableAlarm,    // 计数器报警状态
                                                                    ref Int32 pbDO,         // DO
                                                                    Int32 lChannel);            // 通道号


        //##################################### DIGIT LED 设置函数 #################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDLedMode(                        // 获得显示模式请求
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            ref Int32 lpDispMode);          // 显示模式, 0x00：温度格式,0x01:欧姆值

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDLedMode(                        // 修改显示模式请求
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                            Int32 lDispMode);               // 0x01：温度格式,0x02:欧姆值

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetDLedDispChannel(             // 获得LED显示通道号
                                                                IntPtr hDevice,                 // 设备对象句柄
                                                                ref Int32 lpChannel);               // 通道号,lpChannel = 0xFF:主机控制显示

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDLedDispChannel(             // 设置LED显示通道号
                                                                IntPtr hDevice,                 // 设备对象句柄
                                                                Int32 lChannel);                // 通道号,lpChannel = 0xFF:主机控制显示

        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetDLedValue(                       // 主机控制显示值
                                                            IntPtr hDevice,                 // 设备对象句柄
                                                                                            /*LPCTSTR*/string strWriteBuf,              // 显示的字符串
                                                            Int32 llength);                 // 数据长度


        //////////////////////////////////////////		





        //################################# 看门狗 函数 ##################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_HostIsOK(                                      // Host Is OK
                                                                IntPtr hDevice);			// 设备句柄
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_EnableWatchdog(                                 // 使能看门狗
                                                                IntPtr hDevice);			// 设备句柄
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_CloseWatchdog(                                  // 关闭看门狗
                                                                IntPtr hDevice);			// 设备句柄
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_GetWatchdogSts(                                 // 获得看门狗状态
                                                                IntPtr hDevice,         // 设备句柄
                                                                ref Int32 lpDogStatus);   // 看门狗状态
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ResetWatchdog(                                 // 复位看门狗
                                                                IntPtr hDevice);			// 设备句柄
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SetWatchdogTimeoutVal(                         // 设置看门狗溢出值
                                                                IntPtr hDevice,         // 设备句柄
                                                                Int32 lTimeOutVal);		// 超时时间

        //################################# 精度校验(内部命令) ####################################
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_SlopeProofread(                                 // 斜率校正
                                                                IntPtr hDevice,         // 设备句柄
                                                                Single fSetValue);			// 设置的值
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ZeroProofread(                                  // 零点校正
                                                                IntPtr hDevice,         // 设备句柄
                                                                Single fSetValue);			// 设置的值

        //#########################################################################################
        //********************************* 直接命令行 *********************************
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_WriteDeviceChar(
                                                                IntPtr hDevice,             // 设备句柄
                                                                ref SByte szwriteBuffer,    // 写入的数据
                                                                Int32 llength);			// 直接写设备
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 DAME3000_ReadDeviceChar(
                                                                IntPtr hDevice,             // 设备句柄
                                                                ref SByte szreadBuffer, // 读取的数据
                                                                Int32 llength);			// 直接读设备

        //#########################################################################################
        //********************************* 通用命令 *************************************
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ReadCoils(                                               // 读继电器状态
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,             // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] bCoilsFlag);		// 读取的继电器状态
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ReadDiscretes(                                           // 读开关量输入
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] bDIState);		    // 读取的DI状态
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ReadMultiRegs(                                           // 读保持寄存器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] buf);				// 读取的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ReadInputRegs(                                           // 读输入寄存器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] buf);				// 读取的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 WriteCoil(                                               // 设置单个继电器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Byte status); 			// 写入的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 WriteSingleReg(                                          // 设置单个保持寄存器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int16 val); 			    // 写入的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ForceMultiCoils(                                         // 设置多个继电器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] bDOState);  		// 写入的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 WriteMultiRegs(                                          // 设置多个保持寄存器
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] buf);  			    // 写入的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 ReadRegFile(                                             // 读取文件记录
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 index,                // 文件索引号
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] buf);  			    // 读取的数据
        [DllImport("DAME3000_32.dll")]
        public static extern Int32 WriteRegFile(                                            // 写文件记录
                                                                IntPtr hDevice,             // 设备句柄
                                                                Int32 index,                // 文件索引号
                                                                Int32 addr,                 // 功能地址
                                                                Int32 len,              // 读取长度
                                                                Byte[] buf);                // 写入的数据


    }
    public class DAME3000N
    {
        // 模拟量输入类型(电压类型) 供DAME3000N_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000N_VOLT_N15_P15 = 0x01;	  // -15～+15mV
        public const Int32 DAME3000N_VOLT_N50_P50 = 0x02;	  // -50～+50mV
        public const Int32 DAME3000N_VOLT_N100_P100 = 0x03;	  // -100～+100mV
        public const Int32 DAME3000N_VOLT_N150_P150 = 0x04;	  // -150～+150mV
        public const Int32 DAME3000N_VOLT_N500_P500 = 0x05;	  // -500～+500mV
        public const Int32 DAME3000N_VOLT_N1_P1 = 0x06;	      // -1～+1V
        public const Int32 DAME3000N_VOLT_N25_P25 = 0x07;	  // -2.5～+2.5V
        public const Int32 DAME3000N_VOLT_N5_P5 = 0x08;	      // -5～+5V
        public const Int32 DAME3000N_VOLT_N10_P10 = 0x09;	  // -10～+10V
        public const Int32 DAME3000N_VOLT_N0_P5 = 0x0D;	      // 0～+5V
        public const Int32 DAME3000N_VOLT_N0_P10 = 0x0E;	  // 0～+10V
        public const Int32 DAME3000N_VOLT_N0_P25 = 0x0F;	  // 0～+2.5V
        public const Int32 DAME3000N_VOLT_P1_P5 = 0x82;	      // 1～+5.0V

        // 模拟量输入类型(电流类型) 供DAME3000N_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000N_CUR_N0_P10 = 0x00;	      // 0～10mA
        public const Int32 DAME3000N_CUR_N20_P20 = 0x0A;	  // -20～+20mA
        public const Int32 DAME3000N_CUR_N0_P20 = 0x0B;	      // 0～20mA
        public const Int32 DAME3000N_CUR_P4_P20 = 0x0C;	      // 4～20mA
        public const Int32 DAME3000N_CUR_N0_P22 = 0x80;	      // 0～22mA

        // 模拟量输入类型(热电阻类型) 供DAME3000N_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000N_RTD_CU50 = 0x40;	                // Cu50热电阻 -      50℃～150℃
        public const Int32 DAME3000N_RTD_CU100 = 0x41;                  // Cu100热电阻      -50℃～150℃
        public const Int32 DAME3000N_RTD_PT100_385_N200_P850 = 0x20;	// Pt100(385)热电阻  -200℃～850℃
        public const Int32 DAME3000N_RTD_PT100_385_N100_P100 = 0x21;	// Pt100(385)热电阻  -100℃～100℃
        public const Int32 DAME3000N_RTD_PT100_385_N0_P100 = 0x22;      // Pt100(385)热电阻  0℃～100℃
        public const Int32 DAME3000N_RTD_PT100_385_N0_P200 = 0x23;      // Pt100(385)热电阻  0℃～200℃
        public const Int32 DAME3000N_RTD_PT100_385_N0_P600 = 0x24;      // Pt100(385)热电阻  0℃～600℃
        public const Int32 DAME3000N_RTD_PT100_3916_N200_P850 = 0x25;	// Pt100(3916)热电阻 -200℃～850℃
        public const Int32 DAME3000N_RTD_PT100_3916_N100_P100 = 0x26;	// Pt100(3916)热电阻 -100℃～100℃
        public const Int32 DAME3000N_RTD_PT100_3916_N0_P100 = 0x27;	    // Pt100(3916)热电阻 0℃～100℃
        public const Int32 DAME3000N_RTD_PT100_3916_N0_P200 = 0x28;	    // Pt100(3916)热电阻 0℃～200℃
        public const Int32 DAME3000N_RTD_PT100_3916_N0_P600 = 0x29;	    // Pt100(3916)热电阻 0℃～600℃
        public const Int32 DAME3000N_RTD_PT1000 = 0x30;	                // Pt1000热电阻      -200℃～850℃
        public const Int32 DAME3000N_RTD_BA1 = 0x42;	                // BA1热电阻         -200℃～650℃
        public const Int32 DAME3000N_RTD_BA2 = 0x43;	                // BA2热电阻         -200℃～650℃
        public const Int32 DAME3000N_RTD_G53 = 0x44;	                // G53热电阻         -50℃～150℃
        public const Int32 DAME3000N_RTD_Ni50 = 0x45;	                // Ni50热电阻        100℃～
        public const Int32 DAME3000N_RTD_Ni508 = 0x46;                  // Ni508热电阻       0℃～100℃
        public const Int32 DAME3000N_RTD_Ni1000 = 0x47;                 // Ni1000热电阻      -60℃～160℃

        // 模拟量输入类型(热电偶类型) 供DAME3000N_SetModeAD函数中的nADMode参数使用
        public const Int32 DAME3000N_THERMOCOUPLE_J = 0x10;	// J型热电偶	0℃～1200℃
        public const Int32 DAME3000N_THERMOCOUPLE_K = 0x11;	// K型热电偶	0℃～1300℃
        public const Int32 DAME3000N_THERMOCOUPLE_T = 0x12;	// T型热电偶	-200℃～400℃
        public const Int32 DAME3000N_THERMOCOUPLE_E = 0x13;	// E型热电偶	0℃～1000℃
        public const Int32 DAME3000N_THERMOCOUPLE_R = 0x14;	// R型热电偶	500℃～1700℃
        public const Int32 DAME3000N_THERMOCOUPLE_S = 0x15;	// S型热电偶	500℃～1768℃
        public const Int32 DAME3000N_THERMOCOUPLE_B = 0x16;	// B型热电偶	500℃～1800℃
        public const Int32 DAME3000N_THERMOCOUPLE_N = 0x17;	// N型热电偶	0℃～1300℃
        public const Int32 DAME3000N_THERMOCOUPLE_C = 0x18;	// C型热电偶	0℃～2090℃

        // 数字量输出类型使用
        public const Int32 DAME3000N_OUTPUT_TYPE_DIGIT = 0;		// 数字量输出
        public const Int32 DAME3000N_OUTPUT_TYPE_PULSE = 1;		// 脉冲输出

        // 数字量输入类型 供DAME3000N_SetModeCNT函数中的lCNTMode参数使用
        public const Int32 DAME3000N_DI_MODE_CNT_RISING = 1;	// 上升沿计数
        public const Int32 DAME3000N_DI_MODE_CNT_FALLING = 0;	// 下降沿计数

        // 数字量输出源状态 供DAME3000N_DOGetSourceStatus函数lSourceSts参数使用
        public const Int32 DAME3000N_DO_SOURCE_STATUS_FAILED = 0;// 状态异常
        public const Int32 DAME3000N_DO_SOURCE_STATUS_NORMAL = 1;// 状态正常

        // DI模块的工作模式 供DAME3000N_DISetMode(DAME3000N_DIGetMode)函数中的lMode参数使用
        public const Int32 DAME3000N_DIMODE_DI = 0x01;              // 普通DI量输入模式
        public const Int32 DAME3000N_DIMODE_LATCH_LOWTOHIGH = 0x02; // 低到高锁存模式
        public const Int32 DAME3000N_DIMODE_LATCH_HIGHTOLOW = 0x03; // 低到高锁存模式
        public const Int32 DAME3000N_DIMODE_CNT = 0x04;             // 计数工作模式
        public const Int32 DAME3000N_DIMODE_FREQ = 0x05;            // 频率工作模式

        // DO模块的工作模式 供DAME3000N_DOSetMode(DAME3000N_DOGetMode)函数中的lMode参数使用
        public const Int32 DAME3000N_DOMODE_DO = 1;         // 立即输出
        public const Int32 DAME3000N_DOMODE_LOWTOHIGH = 2;	// 低到高延时输出
        public const Int32 DAME3000N_DOMODE_HIGHTOLOW = 3;	// 高到低延时输出
        public const Int32 DAME3000N_DOMODE_PULSE = 4;      // 脉冲输出

        // 设备网络信息
        public struct _DEVICE_NET_INFO
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
            public Byte[] szIP;					// IP地址, // IP地址, "192.168.2.70"
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
            public Byte[] SubnetMask;			// 子网掩码, "255.255.255.255"
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
            public Byte[] Gateway;				// 网关, "192.168.2.1"
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
            public Byte[] MAC;					// 网卡物理地址,  "00-01-02-03-04-05",用户一般不可修改
            public Int32 lTCPPort;				// TCP端口号
            public Int32 lHTTPPort;				// HTTP端口号
            public Int32 lUDPPort;				// UDP端口号
            public Int32 lMode;					// 连接模式(0: 静态模式  1: DHCP动态模式)
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
            public Byte[] byDevName;			// Device self name
        }
        //####################### 查询模块设备是否在线(DHCP) #######################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Int32 DAME3000N_SearchDevice(  // 创建设备
                                   Byte[] szIP,			    // 设备IP列表
                                   Byte[] szName,		    // 设备名称
                                   Byte[] szMAC,		    // MAC地址
                                   Int32 lPort,			    // UDP端口
                                   ref Int32 plCount,	    // 设备数量
                                   Int32 lSendTimeout,	    // 发送数据的超时间隔 
                                   Int32 lRcvTimeout);	    // 接收数据的超时间隔
        //####################### 设备对象管理函数 #################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern IntPtr DAME3000N_CreateDevice(	// 创建设备
                                    Byte[] szIP,			// 设备IP(如"192.168.1.2")
                                    Int32 lPort,			// TCP端口
                                    Int32 lSendTimeout,	    // 发送数据的超时间隔
                                    Int32 lRcvTimeout);	    // 接收数据的超时间隔
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_ReleaseDevice(IntPtr hDevice);// 释放设备对象
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetDeviceVersion(// 取得设备版本信息
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] szVersion);		    // 设备版本信息
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetNetworkConfig(   // 获得设备的网络配置信息
                                    IntPtr hDevice,                // 设备句柄
                                    ref _DEVICE_NET_INFO pNetInfo);// 网络配置信息
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetNetworkConfigEx(// 获得设备的网络配置信息
                                    IntPtr hDevice,               // 设备句柄
                                    Byte[] szIP,                  // IP地址, IP地址, "192.168.2.70"
                                    Byte[] SubnetMask,            // 子网掩码, "255.255.255.255"
                                    Byte[] Gateway,               // 网关, "192.168.2.1"
                                    Byte[] MAC,                   // 网卡物理地址,  "00-01-02-03-04-05",用户一般不可修改
                                    ref Int32 lpTCPPort,          // TCP端口号
                                    ref Int32 lpHTTPPort,         // HTTP端口号
                                    ref Int32 lpUDPPort,          // UDP端口号
                                    ref Int32 lpMode);            // 连接模式(0: 静态模式  1: DHCP动态模式)
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetNetworkConfig(	// 设置设备的网络配置信息
                                    IntPtr hDevice,			        // 设备句柄
                                    ref _DEVICE_NET_INFO NetInfo);	// 网络配置信息
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetNetworkConfigEx(// 设置设备的网络配置信息
                                    IntPtr hDevice,               // 设备句柄
                                    Byte[] szIP,                  // IP地址, IP地址, "192.168.2.70"
                                    Byte[] SubnetMask,            // 子网掩码, "255.255.255.255"
                                    Byte[] Gateway,               // 网关, "192.168.2.1"
                                    Byte[] MAC,                   // 网卡物理地址,  "00-01-02-03-04-05",用户一般不可修改
                                    Int32 lTCPPort,               // TCP端口号
                                    Int32 lHTTPPort,              // HTTP端口号
                                    Int32 lUDPPort,               // UDP端口号
                                    Int32 lMode);                 // 连接模式(0: 静态模式  1: DHCP动态模式)
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetNetworkInfo(	// 设置网络IP-子网掩码-网关 可跨网段
                                    Byte[] MAC,				    // MAC地址
                                    Byte[] szIP,				// IP地址 "192.168.2.70"
                                    Byte[] SubnetMask,			// 子网掩码 "255.255.255.255"
                                    Byte[] Gateway,			    // 网关 "192.168.2.1"
                                    Int32[] udpPort);			// UDP端口号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SaveIPAddress(Byte[] szIP);		// 保存IP到注册表
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_LoadIPAddress(Byte[] szIP);		// 载入IP到应用程序
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DeviceRestart(IntPtr hDevice);   // 设备重启
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DeviceFacDefault(IntPtr hDevice);// 恢复出厂
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetLastErrorCode(		        // 获取最近一次通信错误码，windows系统定义
                                    IntPtr hDevice,
                                    Int32 lStsCode);
        //################################### AI 函数 ####################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadData(		// 获得模拟量通道输入值（不包括平均值通道）
                                    IntPtr hDevice,				// 设备句柄
                                    UInt16[] lAIValue,			// 返回的AI数据，lAIValue[0]=通道0数据，lAIValue[1]=通道1数据，...，lAIValue[7]=通道7数据，每次读取更新从lFirstChannel到lLastChannel通道内的数据
                                    Int32 lFirstChannel,		// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);		// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadData_Ex(	// 获得模拟量输入值（包括平均值通道）
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt16[] lAIValue,		    // 返回的AI数据，lAIValue的维数为设备支持的通道总数+1维，lAIValue[0]=平均值通道数据，lAIValue[1]=通道0数据，lAIValue[2]=通道2数据，...，lAIValue[8]=通道7数据。函数更新平均值和从lFirstChannel到lLastChannel通道内的数据。
                                    Int32 lFirstChannel,	    // 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);	    // 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadData_Avg(  // 获得模拟量输入平均值通道数据
                                    IntPtr hDevice,			    // 设备句柄
                                    ref UInt16 wAIAverValue);	// 返回AI平均值
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetEnableForAvg(	// 使能AI求平均值
                                    IntPtr hDevice,			        // 设备句柄
                                    Int32 lChannel,			        // 通道号	0=通道0,1=通道1,...,7=通道7
                                    Byte lValue);			        // 是否使能 0-不使能 1-使能
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetEnableForAvg(	// 获取AI通道平均值是否使能
                                    IntPtr hDevice,			        // 设备句柄
                                    Byte[] lValue,			        // 使能数据数组，数组大小为设备支持的通道总数，返回的数据只更新了从lFirstChannel到lLastChannel通道内的数据，1-使能 0-未使能
                                    Int32 lFirstChannel,		    // 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);		    // 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetEnable(	// 使能AI采集通道
                                    IntPtr hDevice,		    // 设备句柄
                                    Int32 lChannel,		    // 通道号 0=通道0,1=通道1,...,7=通道7
                                    Byte lValue);		    // 是否使能 0-不使能 1-使能
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetEnable(	// 获取AI通道采集是否使能
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] lValue,			// 使能数据数组，数组大小为设备支持的总通道数，返回的数据只更新了从lFirstChannel到lLastChannel通道内的数据，1-使能 0-未使能
                                    Int32 lFirstChannel,	// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);	// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadHistData(// 读取AI通道历史最大值最小值，不包括平均值
                                    IntPtr hDevice,			  // 设备句柄
                                    UInt16[] lHistData,		  // 数据，数组大小为设备支持的通道总数，返回的数据只更新了从lFirstChannel到lLastChannel通道内的数据
                                    Int32 lTypeChoose,		  // 选择读取最大值还是最小值,1-最大值，2-最小值
                                    Int32 lFirstChannel,	  // 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);	  // 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadHistData_Avg(// 读取AI通道历史最大(最小)值平均值
                                    IntPtr hDevice,				  // 设备句柄
                                    ref UInt16 wAIHistAverValue,  // 平均值
                                    Int32 lTypeChoose);			  // 选择读取最大值还是最小值,1-最大值，2-最小值
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIReadHistData_Ex(	// 读取AI通道历史最大值(最小值)，包括平均值通道
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt16[] lHistData,		        // 数据，数组大小为设备支持的通道总数+1，lHistData[0]为平均值通道数据，lHistData[1]为通道0数据，,,,，lHistData[8]为通道7数据，返回的数据只更新了从lFirstChannel到lLastChannel通道内的数据
                                    Int32 lDataType,			    // 选择读取最大值还是最小值,1-最大值，2-最小值
                                    Int32 lFirstChannel,		    // 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);		    // 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetRange(	// 设置模拟量输入模式
                                    IntPtr hDevice,			// 设备句柄
                                    Int32[] lAIMode,		// 量程数组，数组大小为设备支持的总通道数
                                    Int32 lFirstChannel,	// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);	// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetRange(	// 获得模拟量输入模式
                                    IntPtr hDevice,			// 设备句柄
                                    Int32[] lAIMode,		// 返回的各个通道的AI模式，数组大小为设备支持的总通道数
                                    Int32 lFirstChannel,	// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);	// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetLimitVal(	// 获得上下限报警值，不包括平均值通道报警值
                                    IntPtr hDevice,				// 设备句柄
                                    UInt16[] lLimitValue,		// 报警值，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内的数据
                                    Int32 lTypeChose,			// 上下限选项 1-上限 2-下限
                                    Int32 lFirstChannel,		// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);		// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetLimitVal_Avg(	// 获得平均值通道上下限报警值
                                    IntPtr hDevice,				    // 设备句柄
                                    ref UInt16 wLimitAverValue,	    // 报警值
                                    Int32 lTypeChose);			    // 上下限选项 1-上限 2-下限
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetLimitVal_Ex(// 获得上下限报警值，包括平均值通道报警值
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt16[] lLimitValue,	    // 报警值，数组大小为设备支持的总通道数+1，lLimitValue[0]为平均值通道报警值，lLimitValue[1]为通道0数据，,,,，lLimitValue[8]为通道7数据，返回的数据只更新从lFirstChannel到lLastChannel通道内的数据
                                    Int32 lTypeChose,		    // 上下限选项 1-上限 2-下限
                                    Int32 lFirstChannel,		// 首通道号 0=通道0,1=通道1,...,7=通道7
                                    Int32 lLastChannel);		// 末通道号 0=通道0,1=通道1,...,7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetLimitVal(	// 设置报警值
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt16 lLimitValue,		    // 报警值
                                    Int32 lLimitType,		    // 上下限选项 1-上限 2-下限
                                    Int32 lChannel);		    // 通道号 0=通道0 1=通道1... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetLimitVal_Ex(// 设置报警值(含平均值通道)
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt16 lLimitValue,		    // 报警值
                                    Int32 lLimitType,		    // 上下限选项 1-上限 2-下限
                                    Int32 lChannel);			// 通道号 0=平均值通道 1=通道0 2=通道1... 8=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmStatus_Avg(// 获取模拟量平均值通道报警状态
                                    IntPtr hDevice,		            // 设备句柄
                                    ref Byte lStatus,		        // 报警状态
                                    Int32 lLimitType);		        // 上下限选择 1-上限 2-下限
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmStatus(// 获取通道报警状态，不包括平均值通道报警状态
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] lStatus,			    // 报警状态，数组大小为设备支持的总通道数
                                    Int32 lLimitType,		    // 上下限选择 1-上限 2-下限
                                    Int32 lFirstChannel,		// 首通道 0=通道0 1=通道1... 7=通道7
                                    Int32 lLastChannel);		// 末通道 0=通道0 1=通道1... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIClearLatchStatus(	// 清除锁存
                                    IntPtr hDevice,		            // 设备句柄
                                    Byte lStatus,		            // 报警状态
                                    Int32 lLimitType,		        // 上限/下限
                                    Int32 lChannel);			    // 通道号 0=通道0 1=通道1... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIClearLatchSts_Avg(	// 清除平均值通道锁存
                                    IntPtr hDevice,		            // 设备句柄
                                    Byte lStatus,		            // 报警状态
                                    Int32 lLimitType);		        // 上限/下限
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmMode(	// 获得报警模式，不包括平均值通道报警模式 0x00-不报警 0x01-锁存 0x02-实时报警
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt16[] lMode,			    // 报警模式，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lTypeChose,		    // 上下限选择，1-上限 2-下限
                                    Int32 lFirstChannel,		// 首通道号 0=通道0 1=通道1... 7=通道7
                                    Int32 lLastChannel);		// 末通道号 0=通道0 1=通道1... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmMode_Avg(	// 获得平均值通道报警模式
                                    IntPtr hDevice,			        // 设备句柄
                                    ref UInt16 lAlarmMode_Avg,	    // 报警模式
                                    Int32 lTypeChose);		        // 上下限选择，1-上限 2-下限
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmMode_Ex(	// 获得报警模式，包括平均值通道报警模式 0x00-不报警 0x01-锁存 0x02-实时报警
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt16[] lMode,			        // 报警模式，数组大小为设备支持的总通道数+1，lMode[0]为平均值通道报警模式，剩余返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lTypeChose,		        // 上下限选择，1-上限 2-下限
                                    Int32 lFirstChannel,		    // 首通道号 0=通道0 1=通道1... 7=通道7
                                    Int32 lLastChannel);		    // 末通道号 0=通道0 1=通道1... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetAlarmMode(	// 设置报警模式 
                                    IntPtr hDevice,		        // 设备句柄
                                    Int16 lAlarmMode,	        // 报警模式 0x00-不报警 0x01-锁存 0x02-实时报警
                                    Int32 lLimitType,	        // 上下限选择，1-上限 2-下限
                                    Int32 lChannel);		    // 通道号 0=通道0 1= 通道1 ... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetAlarmMode_Ex(	// 设置报警模式 (包含平均值通道)
                                    IntPtr hDevice,		            // 设备句柄
                                    Int16 lAlarmMode,	            // 报警模式 0x00-不报警 0x01-锁存 0x02-实时报警
                                    Int32 lLimitType,	            // 上下限选择，1-上限 2-下限
                                    Int32 lChannel);		        // 通道号 0=平均值通道 1= 通道0 2= 通道1 ... 8=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIResetHistValue_Ex(	// 复位通道历史最大值/最小值
                                    IntPtr hDevice,			        // 设备句柄
                                    Int32 lValueType,		        // 最大值/最小值/平均值,1-最大值,2-最小值,3-平均值通道最大值,4-平均值通道最小值
                                    Int32 lChannel);			    // 通道号, 0=通道0 1= 通道1 ... 7=通道7. 当lValueType为平均值通道时，此值无意义
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetBrokenLotusSts(	// 获取断藕状态
                                    IntPtr hDevice,			        // 设备句柄
                                    Byte[] lValue,			        // 断藕状态, 1=断偶, 0=正常, 数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		    // 首通道号 0=通道0 1= 通道1 ... 7=通道7
                                    Int32 lLastChannel);		    // 末通道号 0=通道0 1= 通道1 ... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetGroundRef(	// 设置通道接地模式(只对可软件配置单/双端输入模块有效)
                                    IntPtr hDevice,		        // 设备对象句柄	
                                    Int32 lGroundRef,		    // AI通道接地模式
                                    Int32 lChannel);	        // 通道号 0=通道0 1= 通道1 ... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetGroundRef(	// 获得通道接地模式(只对可软件配置单/双端输入模块有效)
                                    IntPtr hDevice,		        // 设备对象句柄	
                                    ref Int32 lGroundRef,		// AI通道接地模式
                                    Int32 lChannel);	        // 通道号 0=通道0 1= 通道1 ... 7=通道7
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmBindingStatus_Ex(	// 获取DO绑定状态，首通道为平均值通道
                                    IntPtr hDevice,				            // 设备句柄
                                    UInt16[] lStsValue,		                // 绑定的报警通道(DO通道)号，数组大小为设备支持的AI通道总数+1，lStsValue[0]对应平均值通道 lStsValue[1]对应AI0通道 lStsValue[2]对应AI1通道 ... lStsValue[8]对应AI7通道
                                    Int32 lTypeChose,			            // 上下限选择 1-上限 2-下限
                                    Int32 lFirstChannel,		            // AI首通道号
                                    Int32 lLastChannel);		            // AI末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmBindingStatus(	// 获取DO绑定状态，不包括平均值通道
                                    IntPtr hDevice,			            // 设备句柄
                                    UInt16[] lStsValue,		            // 状态，数组大小为设备支持的通道总数，lStsValue[0]对应AI0通道 lStsValue[1]对应AI1通道 ... lStsValue[7]对应AI7通道
                                    Int32 lTypeChose,			        // 上下限选择 1-上限 2-下限
                                    Int32 lFirstChannel,		        // AI首通道号
                                    Int32 lLastChannel);		        // AI末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AIGetAlarmBindingStatus_Avg(	// 获取平均值通道DO绑定状态
                                    IntPtr hDevice,					        // 设备句柄
                                    ref UInt16 lStsValue_Avg,			    // 平均值通道报警绑定的DO通道值
                                    Int32 lTypeChose);			            // 上下限选择 1-上限 2-下限
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AISetAlarmBindingStatus(	// 设置DO绑定状态
                                    IntPtr hDevice,					    // 设备句柄
                                    Int16 lMode,					    // 绑定DO通道号 0=不绑定 1=DO0 2=DO2
                                    Int32 lTypeChose,				    // 上下限选择
                                    Int32 lChannel);					// AI通道号 0=平均值通道 1=AI0 2=AI1 ... 8=AI7
        //################################### DA 函数 ####################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOReadData(	// 回读DA输出值
                                    IntPtr hDevice,	        // 设备对象句柄
                                    ref Int32 lpDAValue,	// DA输出当前值
                                    Int32 lChannel);	    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOWriteData(	// 设定单通道DA
                                    IntPtr hDevice,	        // 设备对象句柄
                                    Int32 lDAData,	        // DA输出值
                                    Int32 lChannel);	    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetRange(	// 读取模拟量输出量程
                                    IntPtr hDevice,		    // 设备对象句柄
                                    ref Int32 lpRange,		// 输出量程
                                    Int32 lChannel);		// 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetRange(	// 设置模拟量输出量程
                                    IntPtr hDevice,		    // 设备对象句柄
                                    Int32 lRange,		    // 输出量程
                                    Int32 lChannel);		// 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetPowerOnValue(	// 获得DA上电值
                                    IntPtr hDevice,		            // 设备对象句柄
                                    ref Int32 lpPowerOnVal, 	    // 上电值
                                    Int32 lChannel);		        // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetPowerOnValue(	// 设置DA上电值
                                    IntPtr hDevice,		            // 设备对象句柄
                                    Int32 lPowerOnVal,	            // 上电值
                                    Int32 lChannel);		        // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetSafeValue(	// 获得DA安全值
                                    IntPtr hDevice,		        // 设备对象句柄
                                    Int32 lpSafeVal,		    // 安全值
                                    Int32 lChannel);		    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetSafeValue(	// 设置DA安全值
                                    IntPtr hDevice,		        // 设备对象句柄
                                    Int32 lSafeVal,		        // 安全值
                                    Int32 lChannel);		    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetSlope(	// 读模拟量输出斜率
                                    IntPtr hDevice,		    // 设备对象句柄
                                    ref Int32 lpSlopeType,	// 输出斜率类型
                                    Int32 lChannel);		// 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetSlope(	// 修改模拟量输出斜率
                                    IntPtr hDevice,		    // 设备对象句柄
                                    Int32 lSlopeType,	    // 输出斜率类型
                                    Int32 lChannel);		// 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOReadData_Addr(	// 回读DA输出值
                                    IntPtr hDevice,	            // 设备对象句柄
                                    Int32 lAddr,                // 首通道地址
                                    ref Int32 lpDAValue,	    // DA输出当前值
                                    Int32 lFirstChannel,        // A0首通道号
                                    Int32 lLastChannel);	    // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOWriteData_Addr(	// 设定单通道DA
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    Int32[] lDAValue,               // DA输出当前值
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetRange_Addr(		// 读取模拟量输出量程
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    ref Int32[] lpRange,            // 输出量程
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetRange_Addr(		// 设置模拟量输出量程
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    Int32[] lRange,                 // 输出量程
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetPowerOnValue_Addr(// 获得DA上电值
                                    IntPtr hDevice,	                  // 设备对象句柄
                                    Int32 lAddr,                      // 首通道地址
                                    ref Int32[] lpPowerOnVal,         // 上电值
                                    Int32 lFirstChannel,	          // A0首通道号
                                    Int32 lLastChannel);	          // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetPowerOnValue_Addr(// 设置DA上电值
                                    IntPtr hDevice,	                  // 设备对象句柄
                                    Int32 lAddr,                      // 首通道地址
                                    Int32[] lPowerOnVal,              // 上电值
                                    Int32 lFirstChannel,	          // A0首通道号
                                    Int32 lLastChannel);	          // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetSafeValue_Addr(   // 获得DA安全值
                                    IntPtr hDevice,	                  // 设备对象句柄
                                    Int32 lAddr,                      // 首通道地址
                                    ref Int32[] lpSafeVal,            // 安全值
                                    Int32 lFirstChannel,	          // A0首通道号
                                    Int32 lLastChannel);	          // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetSafeValue_Addr( // 设置DA安全值
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    Int32[] lSafeVal,               // 安全值
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOGetSlope_Addr(     // 读模拟量输出斜率
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    ref Int32[] lpSlopeType,        // 输出斜率类型
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AOSetSlope_Addr(     // 修改模拟量输出斜率
                                    IntPtr hDevice,	                // 设备对象句柄
                                    Int32 lAddr,                    // 首通道地址
                                    Int32[] lSlopeType,             // 输出斜率类型
                                    Int32 lFirstChannel,	        // A0首通道号
                                    Int32 lLastChannel);	        // A0末通道号
        //################################### DI 函数 ####################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetMode(	    // 设置DI模式状态
                                    IntPtr hDevice,			    // 设备句柄
                                    Int32[] Mode,			    // 模式(0x01 普通DI量输入模式;0x02 低到高锁存;0x03 高到低锁存;0x4 计数工作模式;0x5 频率工作模式;)
                                    Int32 lFirstChannel,		// 首通道号
                                    Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetMode(		// 获取DI工作模式
                                    IntPtr hDevice,			    // 设备句柄
                                    Int32[] pMode,				// 模式，数组大小为设备支持的总通道数，返回的数据只更新了从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		// 首通道号
                                    Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetInvert(	// 设置DI反向逻辑
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] bInversion,		// 是否反向逻辑输入 
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetInvert(	// 获取DI反向逻辑
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] bInversion,		// 是否反向逻辑输入，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetValue(	// 获得DI值
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] byDIStatus,		// DI状态，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetEnableFilter(	// 滤波使能
                                    IntPtr hDevice,			        // 设备句柄
                                    Int32 bEnPulse,			        // 滤波使能
                                    Int32 lChannel);			    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetEnableFilter(	// 获取滤波使能
                                IntPtr hDevice,			            // 设备句柄
                                ref Int32 bEnPulse,			        // 滤波使能
                                Int32 lChannel);			        // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetPulseWidth(	// 设置滤波参数
                                IntPtr hDevice,			        // 设备句柄
                                UInt32[] lLowWidth,		        // 低电平最小宽度
                                UInt32[] lHighWidth,		    // 高信号最小宽度
                                Int32 lFirstChannel,	        // 首通道号
                                Int32 lLastChannel);	        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetPulseWidth(	// 获取滤波参数
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt32[] lLowWidth,		    // 低电平最小宽度
                                    UInt32[] lHighWidth,		// 高信号最小宽度
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIEnablePoweroffSaveforCNT(	// 使能(禁用)断电保存计数器值
                                    IntPtr hDevice,				            // 设备句柄
                                    Int32 bEnPowSave,			            // 断电保存使能 1=使能 0=禁用
                                    Int32 Channel);			                // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetEnablePoweroffSaveforCNT(	// 获取断电保存计数器值使能状态
                                    IntPtr hDevice,					            // 设备句柄
                                    ref Int32 bEnPowSave,					    // 断电保存使能
                                    Int32 Channel);				                // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetCNTInitialValue(	// 设置计数初值
                                    IntPtr hDevice,			            // 设备句柄
                                    UInt32[] lInitialValue,	            // 计数器初值
                                    Int32 lFirstChannel,		        // 首通道号
                                    Int32 lLastChannel);		        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetCNTorFreqValue(	// 获得计数值(频率值)
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt32[] lCurrentVal,		    // 当前值（计数值或频率值，具体数值含义依据当前DI工作模式定义）
                                    Int32 lFirstChannel,	        // 首通道号
                                    Int32 lLastChannel);	        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetCNTOverFlg(	// 获得计数器溢出标志
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] bOverFlg,		    // 溢出标志（0x01 超出计数值不清除  0x00 超出计数值清除）
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIClearCNTOverFlg(	// 清除计数器溢出标志
                                    IntPtr hDevice,				    // 设备句柄
                                    Int32 lFirstChannel,	        // 首通道号
                                    Int32 lLastChannel);	        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DISetStartCNT(	// 设置计数器开始或停止
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] bDICNTSts,			// 计数器状态 0-停止 1-启动
                                    Int32 lFirstChannel,		// 首通道号
                                    Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetStartCNT(	// 获取计数器开始或停止状态
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] bDICNTSts,			// 计数器状态，数组大小为设备支持的总通道数 0-停止 1-启动
                                    Int32 lFirstChannel,		// 首通道号
                                    Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIClearCNTValue(	// 清除计数值
                                    IntPtr hDevice,			    // 设备句柄
                                    Int32 lChannel);		    // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIGetLatchStatus(// 获得DI锁存状态(DAM3201A)
                                    IntPtr hDevice,			    // 设备句柄
                                    Byte[] byLowLatchSts,	    // 下降沿锁存状态，数组大小为设备支持的总通道数
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DIClearLatchStatus(	// 清除锁存状态
                                    IntPtr hDevice,				    // 设备句柄
                                    Int32 lChannel);				// 通道号
        //################################### DO 函数 ####################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetMode(	// 设置DO模式状态
                                    IntPtr hDevice,			// 设备句柄
                                    Int32[] Mode,			// 模式0x01直接输出模式 0x02低到高延时输出 0x03高到低延时输出 0x04 脉冲连续输出 0x05-脉冲固定输出
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetMode(	// 获取DO模式
                                    IntPtr hDevice,			// 设备句柄
                                    Int32[] Mode,			// 模式，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据，0x01直接输出模式 0x02低到高延时输出 0x03高到低延时输出 0x04 脉冲连续输出 0x05-脉冲固定输出
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetValue(	// 获得当前数字量输出
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] byDOSts,			// DO状态，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetValue(	// 设置DO输出值(DAME3021A)
                                    IntPtr hDevice,			// 设备句柄
                                    Byte[] byDOSts,			// 设置DO输出值
                                    Int32 lFirstChannel,	// 首通道号
                                    Int32 lLastChannel);	// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetValue_Line(	// 设置DO输出（单通道设置）
                                    IntPtr hDevice,			    // 设备句柄
                                    Int32 bDOSts,				// DO状态
                                    Int32 lChannel);			// 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetPowerOnValue(	// 设置DO上电值
                                    IntPtr hDevice,		            // 设备句柄
                                    Byte[] bDOSts,		            // 上电值
                                    Int32 lFirstChannel,	        // 首通道号
                                    Int32 lLastChannel);	        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetPowerOnValue(	// 获取DO上电状态
                                    IntPtr hDevice,		            // 设备句柄
                                    Byte[] bDOSts,		            // 上电值，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	        // 首通道号
                                    Int32 lLastChannel);	        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetSafeValue(	// 设置DO安全状态
                                    IntPtr hDevice,		        // 设备句柄
                                    Byte[] bDOSts,		        // 安全值
                                    Int32 lFirstChannel,		// 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetSafeValue(	// 获取DO安全状态
                                    IntPtr hDevice,		        // 设备句柄
                                    Byte[] bDOSts,		        // DO安全状态，数组大小为设置支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);		// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOStartPulseOutput(	// 开始脉冲输出
                                    IntPtr hDevice,			                // 设备句柄
                                    Int32 lChannel);		                // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOStopPulseOutput(	// 停止脉冲输出
                                    IntPtr hDevice,			            // 设备句柄
                                    Int32 lChannel);		            // 通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOGetPulseOutputStatus(// 读取脉冲输出启动停止状态
                                    IntPtr hDevice,				            // 设备句柄
                                    Byte[] bStatus,				            // 返回的状态，数组大小为设备支持的通道总数，返回的数据更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		            // 首通道号
                                    Int32 lLastChannel);		            // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetPulseWidth(	// 设置DO脉冲输出占空比
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt32[] lLowWidth,		    // 脉冲输出低电平宽度
                                    UInt32[] lHighWidth,		// 脉冲输出高电平宽度	
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetPulseWidth(	// 获取DO脉冲输出占空比
                                    IntPtr hDevice,			    // 设备句柄
                                    UInt32[] lLowWidth,		    // 脉冲输出低电平宽度，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    UInt32[] lHighWidth,		// 脉冲输出高电平宽度，数组大小为设备支持的总通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	    // 首通道号
                                    Int32 lLastChannel);	    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOSetPulseAddCount(// 设置续加脉冲数量
                                    IntPtr hDevice,			            // 设备句柄
                                    Int32[] PuAddNum,			        // 续加脉冲个数
                                    Int32 lFirstChannel,	            // 首通道号
                                    Int32 lLastChannel);	            // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_GetDOPulseAddCount(// 获取续加的脉冲数量
                                    IntPtr hDevice,			            // 设备句柄
                                    Int32[] PuAddNum,			        // 续加脉冲个数，数组大小为设备支持的通道总数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	            // 首通道号
                                    Int32 lLastChannel);	            // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetPulseOutputAddCount(// 续加脉冲数量
                                    IntPtr hDevice,		                // 设备句柄
                                    UInt32[] PuAddNum,		            // 续加脉冲个数
                                    Int32 lFirstChannel,		        // 首通道号
                                    Int32 lLastChannel);		        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetPulseOutputAddCount(// 续加脉冲数量
                                    IntPtr hDevice,		                // 设备句柄
                                    UInt32[] PuAddNum,		            // 续加脉冲个数
                                    Int32 lFirstChannel,		        // 首通道号
                                    Int32 lLastChannel);		        // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetPulseOutputCount(// DO0固定脉冲输出(0x0时，连续脉冲输出，其他值时，是配置脉冲输出值)
                                    IntPtr hDevice,			         // 设备句柄
                                    UInt32[] PuOutPutNum,		     // 脉冲个数
                                    Int32 lFirstChannel,	         // 首通道号
                                    Int32 lLastChannel);	         // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetPulseOutputCountLeft(// DO0固定脉冲输出(0x0时，连续脉冲输出，其他值时，是脉冲输出剩余脉冲个数)
                                    IntPtr hDevice,			             // 设备句柄
                                    UInt32[] PuOutPutNum,		         // 脉冲输出剩余个数，数组大小为设备支持的通道数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,	             // 首通道号
                                    Int32 lLastChannel);	             // 末通道号
        // [DllImport("DAME3000N_32.DLL")]
        //public static extern Int32 DAME3000N_GetDevicePulseOutputLeftNum(	//获取脉冲输出剩余个数
        // 									IntPtr	hDevice,				// 设备句柄
        // 									UInt32	lOutputLeftNum[],		// 各通道剩余脉冲个数，数组大小为设备支持的通道总数，返回的数据只更新从lFirstChannel到lLastChannel通道内数据
        // 									Int32	lFirstChannel,			// 首通道号
        // 									Int32	lLastChannel);			// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOSetDelayTime(// 设置DI高低变化延时时间
                                    IntPtr hDevice,				    // 设备句柄
                                    UInt16[] DelayTime,			    // 高到低输出延迟时间
                                    Int32 lFirstChannel,		    // 首通道号
                                    Int32 lLastChannel);		    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_3021N_DOGetDelayTime(// 获取延时时间
                                    IntPtr hDevice,				    // 设备句柄
                                    UInt16[] DelayTime,			    // 高到低输出延迟时间，数组大小为设备支持的通道数，返回的数据更新的是从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		    // 首通道号
                                    Int32 lLastChannel);		    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetLowToHighTime(	// 设置延迟时间(DO由低到高)
                                    IntPtr hDevice,				    // 设备句柄
                                    UInt32[] DelayTime,			    // 低到高输出延迟时间
                                    Int32 lFirstChannel,			// 首通道号
                                    Int32 lLastChannel);			// 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetLowToHighTime(	// 获取延迟时间(DO由低到高)
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt32[] DelayTime,		        // 低到高输出延迟时间，数组大小为设备支持的通道总数，返回的数据更新的是从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		    // 首通道号
                                    Int32 lLastChannel);		    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOSetHighToLowTime(	// 设置延迟时间(DO由高到低)
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt32[] DelayTime,		        // 高到低输出延迟时间
                                    Int32 lFirstChannel,		    // 首通道号
                                    Int32 lLastChannel);		    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetHighToLowTime(	// 获取延迟时间(DO由高到低)
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt32[] DelayTime,		        // 高到低输出延迟时间，数组大小为设备支持的通道总数，返回的数据更新的是从lFirstChannel到lLastChannel通道内数据
                                    Int32 lFirstChannel,		    // 首通道号
                                    Int32 lLastChannel);		    // 末通道号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DOGetSourceStatus(	// 获取DO源状态
                                    IntPtr hDevice,			        // 设备句柄
                                    Int32 lSourceCh,			    // DO Source 通道号 （DAME3022N：DO0~DO3 SourceChannel=0; DO4~DO5 SourceChannel=1）
                                    ref Int32 lSourceSts);		    // DO Source 状态 0=Failed 1=Normal
        //#############################  计数器  ###################################


        //#############################  通用功能  ###################################
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_AdjustTemperature(	// 温度校准
                                    IntPtr hDevice,			        // 设备句柄
                                    Byte lTempValue);		        // 温度值
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_ReadTemperature(	// 读取环境温度
                                  IntPtr hDevice,		        // 设备句柄
                                  ref Double lTempValue);	    // 温度值
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetUDPSearchPort(// 设置UDP搜索端口号
                                    IntPtr hDevice,			    // 设备句柄
                                    Int16 lPortNum);		    // 端口号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetUDPSearchPort(// 读取UDP搜索端口号
                                    IntPtr hDevice,			    // 设备句柄
                                    ref UInt16 pPortNum);		// 端口号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetTCPConnectControl(// 设置TCP连接空闲超时控制
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt16 lEnable);		        // 是否使能 1-使能(必须为1) 
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetTCPConnectControl(// 读取TCP连接空闲超时控制使能状态
                                    IntPtr hDevice,			        // 设备句柄
                                    ref UInt16 pEnable);		    // 是否使能 0-除能 1-使能
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetTCPConnectTime(// 设置TCP连接空闲超时时间
                                    IntPtr hDevice,			     // 设备句柄
                                    UInt16 lTime);			     // 超时时间
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetTCPConnectTime(	// 读取TCP连接空闲超时时间
                                    IntPtr hDevice,			        // 设备句柄
                                    ref UInt16 pTime);			    // 端口号
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_RestartBoard(// 设置是否重新启动寄存器
                                    IntPtr hDevice,			// 设备句柄
                                    UInt16 lRestart);		// 0-不启动 1-重新启动
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_Reset(	// 设置是否恢复出厂设置
                                    IntPtr hDevice,		// 设备句柄
                                    UInt16 lReSet);		// 0-不恢复 1-恢复
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_DevCalibration(	// 设置是否校准
                                    IntPtr hDevice,		        // 设备句柄
                                    UInt16 Calibration);        // 0-不校准 1-校准
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetIPMACFilter(// 设置IP/MAC过滤
                                    IntPtr hDevice,			  // 设备句柄
                                    UInt16 lFilterType,		  // 过滤模式 0-无过滤模式 1-IP过滤 2-MAC过滤
                                    UInt16 lIPEnableNum,	  // IP使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                    UInt16 lMACEnableNum,	  // MAC使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                    Byte[] bIPData,			  // 需要设置的IP数据
                                    Byte[] bMACData);		  // 需要设置的MAC数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetIPMACFilter(	// 读取IP/MAC过滤
                                     IntPtr hDevice,			// 设备句柄
                                     ref UInt16 lFilterType,	// 过滤模式 0-无过滤模式 1-IP过滤 2-MAC过滤
                                     ref UInt16 lIPEnableNum,	// IP使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                     ref UInt16 lMACEnableNum,	// MAC使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                     Byte[] bIPData,			// 读取的IP数据
                                     Byte[] bMACData);		    // 读取的MAC数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetSendToIP(	// 设置定时发送数据参数
                                    IntPtr hDevice,			// 设备句柄
                                    UInt16 lEnableNum,		// IP使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                    Byte[] bIPData,			// 需要设置的IP数据
                                    UInt16[] lTime);		// 需要设置的轮询时间
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetSendToIP(		// 读取定时发送数据参数
                                     IntPtr hDevice,			// 设备句柄
                                     ref UInt16 pEnableNum,		// IP使能序号 bit7 ~bit0：0x01表示0号IP设置，0x03表示0号和1号IP设置，0xFF表示8个全部使能
                                     Byte[] bIPData,			// 读取的IP数据
                                     UInt16[] pTime);		    // 读取的轮询时间
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_PasswordOperation(	// 设置及判断密码是否正确
                                    IntPtr hDevice,			        // 设备句柄
                                    UInt16 lOptionType,		        // 操作类型，1-登录 2-更改密码 回复的时候3-登录失败
                                    Byte[] bOldPassword,	        // 旧密码
                                    Byte[] bNewPassword);	        // 新密码
        //################################# 看门狗 函数 ##################################

        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_HostIsOK(	// Host Is OK
                                    IntPtr hDevice);	    // 设备对象句柄
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_EnableWatchdog(	// 使能看门狗
                                    IntPtr hDevice);	        // 设备对象句柄
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_CloseWatchdog(	// 关闭看门狗
                                    IntPtr hDevice);	        // 设备对象句柄
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetWatchdogSts(	// 获得看门狗状态
                                    IntPtr hDevice,		        // 设备对象句柄
                                    Int32[] lpDogStatus);       // 看门狗状态,lpDogStatus[0]-看门狗是否使能,lpDogStatus[1]-看门狗状态,lpDogStatus[2]-看门狗是否复位
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_ResetWatchdog(	// 复位看门狗
                                    IntPtr hDevice);		    // 设备对象句柄
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_SetWatchdogTimeoutVal(	// 设置看门狗超时时间
                                    IntPtr hDevice,			            // 设备对象句柄
                                    Int32 lTimeOutVal);		            // 超时时间
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean DAME3000N_GetWatchdogTimeout(	// 获取看门狗超时时间
                                    IntPtr hDevice,				    // 设备对象句柄
                                    ref Int32 pTimeOut);			// 超时时间
        //#########################################################################################
        //********************************* 直接命令行 *********************************
        [DllImport("DAME3000N_32.DLL")]
        public static extern Int32 DAME3000N_WriteDeviceChar(
                                  IntPtr hDevice, 		    // 设备句柄
                                  ref Byte szwriteBuffer,	// 写入的数据
                                  Int32 llength);		    // 直接写设备
        [DllImport("DAME3000N_32.DLL")]
        public static extern Int32 DAME3000N_ReadDeviceChar(
                                  IntPtr hDevice,		    // 设备句柄
                                  ref Byte szreadBuffer,	// 读取的数据
                                  Int32 llength);		    // 直接读设备
        //#########################################################################################
        //********************************* 通用命令 *************************************
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ReadCoils(			// 读继电器状态
                                    IntPtr hDevice,		// 设备句柄
                                    Int32 addr,			// 功能地址
                                    Int32 len,			// 读取长度
                                    Byte[] bCoilsFlag);	// 读取的继电器状态
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ReadDiscretes(		// 读开关量输入
                                    IntPtr hDevice,		// 设备句柄
                                    Int32 addr,			// 功能地址
                                    Int32 len,			// 读取长度
                                    Byte[] bDIState);	// 读取的DI状态
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ReadMultiRegs(		// 读保持寄存器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Int32 len, 			// 读取长度
                                    Byte[] buf);		// 读取的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ReadInputRegs(		// 读输入寄存器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Int32 len, 			// 读取长度
                                    Byte[] buf);		// 读取的数据Z
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean WriteCoil(			// 设置单个继电器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Byte status); 		// 写入的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean WriteSingleReg(	// 设置单个保持寄存器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Int16 val);  		// 写入的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ForceMultiCoils(	// 设置多个继电器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Int32 len, 			// 读取长度
                                    Byte[] bDOState);  	// 写入的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean WriteMultiRegs(	// 设置多个保持寄存器
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 addr, 		// 功能地址
                                    Int32 len, 			// 读取长度
                                    Byte[] buf);  		// 写入的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean ReadRegFile(		// 读取文件记录
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 index,	    // 文件索引号
                                    Int32 addr, 		// 功能地址
                                    Int32 len, 			// 读取长度
                                    Byte[] buf);  		// 读取的数据
        [DllImport("DAME3000N_32.DLL")]
        public static extern Boolean WriteRegFile(		// 写文件记录
                                    IntPtr hDevice,  	// 设备句柄
                                    Int32 index, 		// 文件索引号
                                    Int32 addr, 		// 功能地址
                                    Int32 len,			// 读取长度
                                    Byte[] buf);  		// 写入的数据
    }
}
